mcs/class/referencesource/mscorlib/system/threading/executioncontext.cs

   1 #if MOBILE_LEGACY
   2 #define FEATURE_REMOTING
   3 #endif
   4 // ==++==
   5 //
   6 //   Copyright (c) Microsoft Corporation.  All rights reserved.
   7 //
   8 //
   9 // <OWNER>Microsoft</OWNER>
  10 /*============================================================
  11 **
  12 ** Class:  ExecutionContext
  13 **
  14 **
  15 ** Purpose: Capture execution  context for a thread
  16 **
  17 **
  18 ===========================================================*/
  19 namespace System.Threading
  20 {
  21     using System;
  22     using System.Security;
  23     using System.Runtime.Remoting;
  24     using System.Security.Principal;
  25     using System.Collections;
  26     using System.Collections.Generic;
  27     using System.Reflection;
  28     using System.Runtime.ExceptionServices;
  29     using System.Runtime.Serialization;
  30     using System.Security.Permissions;
  31 #if FEATURE_REMOTING
  32     using System.Runtime.Remoting.Messaging;
  33 #endif // FEATURE_REMOTING
  34     using System.Runtime.InteropServices;
  35     using System.Runtime.CompilerServices;
  36     using System.Runtime.ConstrainedExecution;
  37     using System.Diagnostics.Contracts;
  38     using System.Diagnostics.CodeAnalysis;
  39
  40 #if FEATURE_CORECLR
  41     [System.Security.SecurityCritical] // auto-generated
  42 #endif
  43     [System.Runtime.InteropServices.ComVisible(true)]
  44     public delegate void ContextCallback(Object state);
  45
  46 #if FEATURE_CORECLR
  47
  48     [SecurityCritical]
  49     internal struct ExecutionContextSwitcher
  50     {
  51         internal ExecutionContext m_ec;
  52         internal SynchronizationContext m_sc;
  53
  54         internal void Undo()
  55         {
  56             SynchronizationContext.SetSynchronizationContext(m_sc);
  57             ExecutionContext.Restore(m_ec);
  58         }
  59     }
  60
  61     public sealed class ExecutionContext : IDisposable
  62     {
  63         public static readonly ExecutionContext Default = new ExecutionContext();
  64
  65         [ThreadStatic]
  66         [SecurityCritical]
  67         static ExecutionContext t_currentMaybeNull;
  68
  69         private readonly Dictionary<IAsyncLocal, object> m_localValues;
  70         private readonly List<IAsyncLocal> m_localChangeNotifications;
  71
  72         private ExecutionContext()
  73         {
  74             m_localValues = new Dictionary<IAsyncLocal, object>();
  75             m_localChangeNotifications = new List<IAsyncLocal>();
  76         }
  77
  78         private ExecutionContext(ExecutionContext other)
  79         {
  80             m_localValues = new Dictionary<IAsyncLocal, object>(other.m_localValues);
  81             m_localChangeNotifications = new List<IAsyncLocal>(other.m_localChangeNotifications);
  82         }
  83
  84         [SecuritySafeCritical]
  85         public static ExecutionContext Capture()
  86         {
  87             return t_currentMaybeNull ?? ExecutionContext.Default;
  88         }
  89
  90         [SecurityCritical]
  91         [HandleProcessCorruptedStateExceptions]
  92         public static void Run(ExecutionContext executionContext, ContextCallback callback, Object state)
  93         {
  94             ExecutionContextSwitcher ecsw = default(ExecutionContextSwitcher);
  95             try
  96             {
  97                 EstablishCopyOnWriteScope(ref ecsw);
  98
  99                 ExecutionContext.Restore(executionContext);
 100                 callback(state);
 101             }
 102             catch
 103             {
 104                 // Note: we have a "catch" rather than a "finally" because we want
 105                 // to stop the first pass of EH here.  That way we can restore the previous
 106                 // context before any of our callers' EH filters run.  That means we need to
 107                 // end the scope separately in the non-exceptional case below.
 108                 ecsw.Undo();
 109                 throw;
 110             }
 111             ecsw.Undo();
 112         }
 113
 114         [SecurityCritical]
 115         internal static void Restore(ExecutionContext executionContext)
 116         {
 117             if (executionContext == null)
 118                 throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NullContext"));
 119
 120             ExecutionContext previous = t_currentMaybeNull ?? Default;
 121             t_currentMaybeNull = executionContext;
 122
 123             if (previous != executionContext)
 124                 OnContextChanged(previous, executionContext);
 125         }
 126
 127         [SecurityCritical]
 128         static internal void EstablishCopyOnWriteScope(ref ExecutionContextSwitcher ecsw)
 129         {
 130             ecsw.m_ec = Capture();
 131             ecsw.m_sc = SynchronizationContext.CurrentNoFlow;
 132         }
 133
 134         [SecurityCritical]
 135         [HandleProcessCorruptedStateExceptions]
 136         private static void OnContextChanged(ExecutionContext previous, ExecutionContext current)
 137         {
 138             previous = previous ?? Default;
 139
 140             foreach (IAsyncLocal local in previous.m_localChangeNotifications)
 141             {
 142                 object previousValue;
 143                 object currentValue;
 144                 previous.m_localValues.TryGetValue(local, out previousValue);
 145                 current.m_localValues.TryGetValue(local, out currentValue);
 146
 147                 if (previousValue != currentValue)
 148                     local.OnValueChanged(previousValue, currentValue, true);
 149             }
 150
 151             if (current.m_localChangeNotifications != previous.m_localChangeNotifications)
 152             {
 153                 try
 154                 {
 155                     foreach (IAsyncLocal local in current.m_localChangeNotifications)
 156                     {
 157                         // If the local has a value in the previous context, we already fired the event for that local
 158                         // in the code above.
 159                         object previousValue;
 160                         if (!previous.m_localValues.TryGetValue(local, out previousValue))
 161                         {
 162                             object currentValue;
 163                             current.m_localValues.TryGetValue(local, out currentValue);
 164
 165                             if (previousValue != currentValue)
 166                                 local.OnValueChanged(previousValue, currentValue, true);
 167                         }
 168                     }
 169                 }
 170                 catch (Exception ex)
 171                 {
 172                     Environment.FailFast(
 173                         Environment.GetResourceString("ExecutionContext_ExceptionInAsyncLocalNotification"),
 174                         ex);
 175                 }
 176             }
 177         }
 178
 179         [SecurityCritical]
 180         internal static object GetLocalValue(IAsyncLocal local)
 181         {
 182             ExecutionContext current = t_currentMaybeNull;
 183             if (current == null)
 184                 return null;
 185
 186             object value;
 187             current.m_localValues.TryGetValue(local, out value);
 188             return value;
 189         }
 190
 191         [SecurityCritical]
 192         internal static void SetLocalValue(IAsyncLocal local, object newValue, bool needChangeNotifications)
 193         {
 194             ExecutionContext current = t_currentMaybeNull ?? ExecutionContext.Default;
 195
 196             object previousValue;
 197             bool hadPreviousValue = current.m_localValues.TryGetValue(local, out previousValue);
 198
 199             if (previousValue == newValue)
 200                 return;
 201
 202             current = new ExecutionContext(current);
 203             current.m_localValues[local] = newValue;
 204
 205             t_currentMaybeNull = current;
 206
 207             if (needChangeNotifications)
 208             {
 209                 if (hadPreviousValue)
 210                     Contract.Assert(current.m_localChangeNotifications.Contains(local));
 211                 else
 212                     current.m_localChangeNotifications.Add(local);
 213
 214                 local.OnValueChanged(previousValue, newValue, false);
 215             }
 216         }
 217
 218     #region Wrappers for CLR compat, to avoid ifdefs all over the BCL
 219
 220         [Flags]
 221         internal enum CaptureOptions
 222         {
 223             None = 0x00,
 224             IgnoreSyncCtx = 0x01,
 225             OptimizeDefaultCase = 0x02,
 226         }
 227
 228         [SecurityCritical]
 229         internal static ExecutionContext Capture(ref StackCrawlMark stackMark, CaptureOptions captureOptions)
 230         {
 231             return Capture();
 232         }
 233
 234         [SecuritySafeCritical]
 235         [FriendAccessAllowed]
 236         internal static ExecutionContext FastCapture()
 237         {
 238             return Capture();
 239         }
 240
 241         [SecurityCritical]
 242         [FriendAccessAllowed]
 243         internal static void Run(ExecutionContext executionContext, ContextCallback callback, Object state, bool preserveSyncCtx)
 244         {
 245             Run(executionContext, callback, state);
 246         }
 247
 248         [SecurityCritical]
 249         internal bool IsDefaultFTContext(bool ignoreSyncCtx)
 250         {
 251             ExecutionContext current = t_currentMaybeNull;
 252             return current == null || current == Default;
 253         }
 254
 255         [SecuritySafeCritical]
 256         public ExecutionContext CreateCopy()
 257         {
 258             return this; // since CoreCLR's ExecutionContext is immutable, we don't need to create copies.
 259         }
 260
 261         public void Dispose()
 262         {
 263             // For CLR compat only
 264         }
 265
 266         public static bool IsFlowSuppressed()
 267         {
 268             return false;
 269         }
 270
 271         internal static ExecutionContext PreAllocatedDefault
 272         {
 273             [SecuritySafeCritical]
 274             get { return ExecutionContext.Default; }
 275         }
 276
 277         internal bool IsPreAllocatedDefault
 278         {
 279             get { return this == ExecutionContext.Default; }
 280         }
 281
 282     #endregion
 283     }
 284
 285 #else // FEATURE_CORECLR
 286
 287     // Legacy desktop ExecutionContext implementation
 288
 289     internal struct ExecutionContextSwitcher
 290     {
 291         internal ExecutionContext.Reader outerEC; // previous EC we need to restore on Undo
 292         internal bool outerECBelongsToScope;
 293 #if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK
 294         internal SecurityContextSwitcher scsw;
 295 #endif // #if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK
 296         internal Object hecsw;
 297 #if !FEATURE_PAL && FEATURE_IMPERSONATION
 298         internal WindowsIdentity wi;
 299         internal bool cachedAlwaysFlowImpersonationPolicy;
 300         internal bool wiIsValid;
 301 #endif
 302         internal Thread thread;
 303
 304         [System.Security.SecurityCritical]  // auto-generated
 305         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
 306 #if FEATURE_CORRUPTING_EXCEPTIONS
 307         [HandleProcessCorruptedStateExceptions] //
 308 #endif // FEATURE_CORRUPTING_EXCEPTIONS
 309         internal bool UndoNoThrow()
 310         {
 311             try
 312             {
 313                 Undo();
 314             }
 315             catch
 316             {
 317                 return false;
 318             }
 319             return true;
 320         }
 321
 322         [System.Security.SecurityCritical]  // auto-generated
 323         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
 324         internal void Undo()
 325         {
 326             //
 327             // Don't use an uninitialized switcher, or one that's already been used.
 328             //
 329             if (thread == null)
 330                 return; // Don't do anything
 331
 332             Contract.Assert(Thread.CurrentThread == this.thread);
 333             Thread currentThread = this.thread;
 334
 335             //
 336             // Restore the HostExecutionContext before restoring the ExecutionContext.
 337             //
 338 #if FEATURE_CAS_POLICY
 339             if (hecsw != null)
 340                 HostExecutionContextSwitcher.Undo(hecsw);
 341 #endif // FEATURE_CAS_POLICY
 342
 343             //
 344             // restore the saved Execution Context.  Note that this will also restore the
 345             // SynchronizationContext, Logical/IllogicalCallContext, etc.
 346             //
 347             ExecutionContext.Reader innerEC = currentThread.GetExecutionContextReader();
 348             currentThread.SetExecutionContext(outerEC, outerECBelongsToScope);
 349
 350 #if !MONO && DEBUG
 351             try
 352             {
 353                 currentThread.ForbidExecutionContextMutation = true;
 354 #endif
 355
 356                 //
 357                 // Tell the SecurityContext to do the side-effects of restoration.
 358                 //
 359 #if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK
 360                 if (scsw.currSC != null)
 361                 {
 362                     // Any critical failure inside scsw will cause FailFast
 363                     scsw.Undo();
 364                 }
 365 #endif // #if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK
 366
 367 #if !FEATURE_PAL && FEATURE_IMPERSONATION
 368                 if (wiIsValid)
 369                     SecurityContext.RestoreCurrentWI(outerEC, innerEC, wi, cachedAlwaysFlowImpersonationPolicy);
 370 #endif
 371
 372                 thread = null; // this will prevent the switcher object being used again
 373 #if !MONO && DEBUG
 374             }
 375             finally
 376             {
 377                 currentThread.ForbidExecutionContextMutation = false;
 378             }
 379 #endif
 380             ExecutionContext.OnAsyncLocalContextChanged(innerEC.DangerousGetRawExecutionContext(), outerEC.DangerousGetRawExecutionContext());
 381         }
 382     }
 383
 384
 385     public struct AsyncFlowControl: IDisposable
 386     {
 387         private bool useEC;
 388         private ExecutionContext _ec;
 389 #if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK
 390         private SecurityContext _sc;
 391 #endif // #if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK
 392         private Thread _thread;
 393 #if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK
 394         [SecurityCritical]
 395         internal void Setup(SecurityContextDisableFlow flags)
 396         {
 397             useEC = false;
 398             Thread currentThread = Thread.CurrentThread;
 399             _sc = currentThread.GetMutableExecutionContext().SecurityContext;
 400             _sc._disableFlow = flags;
 401             _thread = currentThread;
 402         }
 403 #endif // #if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK
 404         [SecurityCritical]
 405         internal void Setup()
 406         {
 407             useEC = true;
 408             Thread currentThread = Thread.CurrentThread;
 409             _ec = currentThread.GetMutableExecutionContext();
 410             _ec.isFlowSuppressed = true;
 411             _thread = currentThread;
 412         }
 413
 414         public void Dispose()
 415         {
 416             Undo();
 417         }
 418
 419         [SecuritySafeCritical]
 420         public void Undo()
 421         {
 422             if (_thread == null)
 423             {
 424                 throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_CannotUseAFCMultiple"));
 425             }
 426             if (_thread != Thread.CurrentThread)
 427             {
 428                 throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_CannotUseAFCOtherThread"));
 429             }
 430             if (useEC)
 431             {
 432                 if (Thread.CurrentThread.GetMutableExecutionContext() != _ec)
 433                 {
 434                     throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_AsyncFlowCtrlCtxMismatch"));
 435                 }
 436                 ExecutionContext.RestoreFlow();
 437             }
 438 #if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK
 439             else
 440             {
 441                 if (!Thread.CurrentThread.GetExecutionContextReader().SecurityContext.IsSame(_sc))
 442                 {
 443                     throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_AsyncFlowCtrlCtxMismatch"));
 444                 }
 445                 SecurityContext.RestoreFlow();
 446             }
 447 #endif // #if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK
 448             _thread = null;
 449         }
 450
 451         public override int GetHashCode()
 452         {
 453             // review - Microsoft
 454             return _thread == null ? ToString().GetHashCode() : _thread.GetHashCode();
 455         }
 456
 457         public override bool Equals(Object obj)
 458         {
 459             if (obj is AsyncFlowControl)
 460                 return Equals((AsyncFlowControl)obj);
 461             else
 462                 return false;
 463         }
 464
 465         public bool Equals(AsyncFlowControl obj)
 466         {
 467             return obj.useEC == useEC && obj._ec == _ec &&
 468 #if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK
 469                 obj._sc == _sc &&
 470 #endif // #if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK
 471                 obj._thread == _thread;
 472         }
 473
 474         public static bool operator ==(AsyncFlowControl a, AsyncFlowControl b)
 475         {
 476             return a.Equals(b);
 477         }
 478
 479         public static bool operator !=(AsyncFlowControl a, AsyncFlowControl b)
 480         {
 481             return !(a == b);
 482         }
 483
 484     }
 485
 486
 487     [Serializable]
 488     public sealed class ExecutionContext : IDisposable, ISerializable
 489     {
 490         /*=========================================================================
 491         ** Data accessed from managed code that needs to be defined in
 492         ** ExecutionContextObject  to maintain alignment between the two classes.
 493         ** DON'T CHANGE THESE UNLESS YOU MODIFY ExecutionContextObject in vm\object.h
 494         =========================================================================*/
 495 #if FEATURE_CAS_POLICY
 496         private HostExecutionContext _hostExecutionContext;
 497 #endif // FEATURE_CAS_POLICY
 498         private SynchronizationContext _syncContext;
 499         private SynchronizationContext _syncContextNoFlow;
 500 #if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK
 501         private SecurityContext     _securityContext;
 502 #endif // #if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK
 503 #if FEATURE_REMOTING
 504         [System.Security.SecurityCritical] // auto-generated
 505         private LogicalCallContext  _logicalCallContext;
 506         private IllogicalCallContext _illogicalCallContext;  // this call context follows the physical thread
 507 #endif // #if FEATURE_REMOTING
 508
 509         enum Flags
 510         {
 511             None = 0x0,
 512             IsNewCapture = 0x1,
 513             IsFlowSuppressed = 0x2,
 514             IsPreAllocatedDefault = 0x4
 515         }
 516         private Flags _flags;
 517
 518         private Dictionary<IAsyncLocal, object> _localValues;
 519         private List<IAsyncLocal> _localChangeNotifications;
 520
 521         internal bool isNewCapture
 522         {
 523             get
 524             {
 525                 return (_flags & (Flags.IsNewCapture | Flags.IsPreAllocatedDefault)) != Flags.None;
 526             }
 527             set
 528             {
 529                 Contract.Assert(!IsPreAllocatedDefault);
 530                 if (value)
 531                     _flags |= Flags.IsNewCapture;
 532                 else
 533                     _flags &= ~Flags.IsNewCapture;
 534             }
 535         }
 536         internal bool isFlowSuppressed
 537         {
 538             get
 539             {
 540                 return (_flags & Flags.IsFlowSuppressed) != Flags.None;
 541             }
 542             set
 543             {
 544                 Contract.Assert(!IsPreAllocatedDefault);
 545                 if (value)
 546                     _flags |= Flags.IsFlowSuppressed;
 547                 else
 548                     _flags &= ~Flags.IsFlowSuppressed;
 549             }
 550         }
 551
 552
 553         private static readonly ExecutionContext s_dummyDefaultEC = new ExecutionContext(isPreAllocatedDefault: true);
 554
 555         static internal ExecutionContext PreAllocatedDefault
 556         {
 557             [SecuritySafeCritical]
 558             get { return s_dummyDefaultEC; }
 559         }
 560
 561         internal bool IsPreAllocatedDefault
 562         {
 563             get
 564             {
 565                 // we use _flags instead of a direct comparison w/ s_dummyDefaultEC to avoid the static access on
 566                 // hot code paths.
 567                 if ((_flags & Flags.IsPreAllocatedDefault) != Flags.None)
 568                 {
 569                     Contract.Assert(this == s_dummyDefaultEC);
 570                     return true;
 571                 }
 572                 else
 573                 {
 574                     return false;
 575                 }
 576             }
 577         }
 578
 579 #if MONO
 580         internal static readonly ExecutionContext Default = new ExecutionContext();
 581 #endif
 582
 583         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
 584         internal ExecutionContext()
 585         {
 586         }
 587
 588         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
 589         internal ExecutionContext(bool isPreAllocatedDefault)
 590         {
 591             if (isPreAllocatedDefault)
 592                 _flags = Flags.IsPreAllocatedDefault;
 593         }
 594
 595         // Read-only wrapper around ExecutionContext.  This enables safe reading of an ExecutionContext without accidentally modifying it.
 596         internal struct Reader
 597         {
 598             ExecutionContext m_ec;
 599
 600             public Reader(ExecutionContext ec) { m_ec = ec; }
 601
 602             public ExecutionContext DangerousGetRawExecutionContext() { return m_ec; }
 603
 604             public bool IsNull { get { return m_ec == null; } }
 605             [SecurityCritical]
 606             public bool IsDefaultFTContext(bool ignoreSyncCtx) { return m_ec.IsDefaultFTContext(ignoreSyncCtx); }
 607             public bool IsFlowSuppressed
 608             {
 609                 [MethodImpl(MethodImplOptions.AggressiveInlining)]
 610                 get { return IsNull ? false : m_ec.isFlowSuppressed; }
 611             }
 612             //public Thread Thread { get { return m_ec._thread; } }
 613             public bool IsSame(ExecutionContext.Reader other) { return m_ec == other.m_ec; }
 614
 615             public SynchronizationContext SynchronizationContext { get { return IsNull ? null : m_ec.SynchronizationContext; } }
 616             public SynchronizationContext SynchronizationContextNoFlow { get { return IsNull ? null : m_ec.SynchronizationContextNoFlow; } }
 617
 618 #if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK
 619             public SecurityContext.Reader SecurityContext
 620             {
 621                 [SecurityCritical]
 622                 [MethodImpl(MethodImplOptions.AggressiveInlining)]
 623                 get { return new SecurityContext.Reader(IsNull ? null : m_ec.SecurityContext); }
 624             }
 625 #endif
 626
 627 #if FEATURE_REMOTING
 628             public LogicalCallContext.Reader LogicalCallContext
 629             {
 630                 [SecurityCritical]
 631                 get { return new LogicalCallContext.Reader(IsNull ? null : m_ec.LogicalCallContext); }
 632             }
 633
 634             public IllogicalCallContext.Reader IllogicalCallContext
 635             {
 636                 [SecurityCritical]
 637                 get { return new IllogicalCallContext.Reader(IsNull ? null : m_ec.IllogicalCallContext); }
 638             }
 639 #endif
 640
 641             [SecurityCritical]
 642             public object GetLocalValue(IAsyncLocal local)
 643             {
 644                 if (IsNull)
 645                     return null;
 646
 647                 if (m_ec._localValues == null)
 648                     return null;
 649
 650                 object value;
 651                 m_ec._localValues.TryGetValue(local, out value);
 652                 return value;
 653             }
 654
 655             [SecurityCritical]
 656             public bool HasSameLocalValues(ExecutionContext other)
 657             {
 658                 var thisLocalValues = IsNull ? null : m_ec._localValues;
 659                 var otherLocalValues = other == null ? null : other._localValues;
 660                 return thisLocalValues == otherLocalValues;
 661             }
 662
 663             [SecurityCritical]
 664             public bool HasLocalValues()
 665             {
 666                 return !this.IsNull && m_ec._localValues != null;
 667             }
 668         }
 669
 670         [SecurityCritical]
 671         internal static object GetLocalValue(IAsyncLocal local)
 672         {
 673             return Thread.CurrentThread.GetExecutionContextReader().GetLocalValue(local);
 674         }
 675
 676         [SecurityCritical]
 677         internal static void SetLocalValue(IAsyncLocal local, object newValue, bool needChangeNotifications)
 678         {
 679             ExecutionContext current = Thread.CurrentThread.GetMutableExecutionContext();
 680
 681             object previousValue = null;
 682             bool hadPreviousValue = current._localValues != null && current._localValues.TryGetValue(local, out previousValue);
 683
 684             if (previousValue == newValue)
 685                 return;
 686
 687             if (current._localValues == null)
 688                 current._localValues = new Dictionary<IAsyncLocal, object>();
 689             else
 690                 current._localValues = new Dictionary<IAsyncLocal, object>(current._localValues);
 691
 692             current._localValues[local] = newValue;
 693
 694             if (needChangeNotifications)
 695             {
 696                 if (hadPreviousValue)
 697                 {
 698                     Contract.Assert(current._localChangeNotifications != null);
 699                     Contract.Assert(current._localChangeNotifications.Contains(local));
 700                 }
 701                 else
 702                 {
 703                     if (current._localChangeNotifications == null)
 704                         current._localChangeNotifications = new List<IAsyncLocal>();
 705                     else
 706                         current._localChangeNotifications = new List<IAsyncLocal>(current._localChangeNotifications);
 707
 708                     current._localChangeNotifications.Add(local);
 709                 }
 710
 711                 local.OnValueChanged(previousValue, newValue, false);
 712             }
 713         }
 714
 715         [SecurityCritical]
 716         [HandleProcessCorruptedStateExceptions]
 717         internal static void OnAsyncLocalContextChanged(ExecutionContext previous, ExecutionContext current)
 718         {
 719             List<IAsyncLocal> previousLocalChangeNotifications = (previous == null) ? null : previous._localChangeNotifications;
 720             if (previousLocalChangeNotifications != null)
 721             {
 722                 foreach (IAsyncLocal local in previousLocalChangeNotifications)
 723                 {
 724                     object previousValue = null;
 725                     if (previous != null && previous._localValues != null)
 726                         previous._localValues.TryGetValue(local, out previousValue);
 727
 728                     object currentValue = null;
 729                     if (current != null && current._localValues != null)
 730                         current._localValues.TryGetValue(local, out currentValue);
 731
 732                     if (previousValue != currentValue)
 733                         local.OnValueChanged(previousValue, currentValue, true);
 734                 }
 735             }
 736
 737             List<IAsyncLocal> currentLocalChangeNotifications = (current == null) ? null : current._localChangeNotifications;
 738             if (currentLocalChangeNotifications != null && currentLocalChangeNotifications != previousLocalChangeNotifications)
 739             {
 740                 try
 741                 {
 742                     foreach (IAsyncLocal local in currentLocalChangeNotifications)
 743                     {
 744                         // If the local has a value in the previous context, we already fired the event for that local
 745                         // in the code above.
 746                         object previousValue = null;
 747                         if (previous == null ||
 748                             previous._localValues == null ||
 749                             !previous._localValues.TryGetValue(local, out previousValue))
 750                         {
 751                             object currentValue = null;
 752                             if (current != null && current._localValues != null)
 753                                 current._localValues.TryGetValue(local, out currentValue);
 754
 755                             if (previousValue != currentValue)
 756                                 local.OnValueChanged(previousValue, currentValue, true);
 757                         }
 758                     }
 759                 }
 760                 catch (Exception ex)
 761                 {
 762                     Environment.FailFast(
 763                         Environment.GetResourceString("ExecutionContext_ExceptionInAsyncLocalNotification"),
 764                         ex);
 765                 }
 766             }
 767         }
 768
 769
 770 #if FEATURE_REMOTING
 771         internal LogicalCallContext LogicalCallContext
 772         {
 773             [System.Security.SecurityCritical]  // auto-generated
 774             get
 775             {
 776                 if (_logicalCallContext == null)
 777                 {
 778                 _logicalCallContext = new LogicalCallContext();
 779                 }
 780                 return _logicalCallContext;
 781             }
 782             [System.Security.SecurityCritical]  // auto-generated
 783             set
 784             {
 785                 Contract.Assert(this != s_dummyDefaultEC);
 786                 _logicalCallContext = value;
 787             }
 788         }
 789
 790         internal IllogicalCallContext IllogicalCallContext
 791         {
 792             get
 793             {
 794                 if (_illogicalCallContext == null)
 795                 {
 796                 _illogicalCallContext = new IllogicalCallContext();
 797                 }
 798                 return _illogicalCallContext;
 799             }
 800             set
 801             {
 802                 Contract.Assert(this != s_dummyDefaultEC);
 803                 _illogicalCallContext = value;
 804             }
 805         }
 806 #endif // #if FEATURE_REMOTING
 807
 808         internal SynchronizationContext SynchronizationContext
 809         {
 810             [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
 811             get
 812             {
 813                 return _syncContext;
 814             }
 815             [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
 816             set
 817             {
 818                 Contract.Assert(this != s_dummyDefaultEC);
 819                 _syncContext = value;
 820             }
 821         }
 822
 823         internal SynchronizationContext SynchronizationContextNoFlow
 824         {
 825             [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
 826             get
 827             {
 828                 return _syncContextNoFlow;
 829             }
 830             [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
 831             set
 832             {
 833                 Contract.Assert(this != s_dummyDefaultEC);
 834                 _syncContextNoFlow = value;
 835             }
 836         }
 837
 838 #if FEATURE_CAS_POLICY
 839     internal HostExecutionContext HostExecutionContext
 840     {
 841             get
 842             {
 843                 return _hostExecutionContext;
 844             }
 845             set
 846             {
 847                 Contract.Assert(this != s_dummyDefaultEC);
 848                 _hostExecutionContext = value;
 849             }
 850     }
 851 #endif // FEATURE_CAS_POLICY
 852 #if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK
 853         internal  SecurityContext SecurityContext
 854         {
 855             [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
 856             get
 857             {
 858                 return _securityContext;
 859             }
 860             [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
 861             set
 862             {
 863                 Contract.Assert(this != s_dummyDefaultEC);
 864                         // store the new security context
 865                         _securityContext = value;
 866                         // perform the reverse link too
 867                         if (value != null)
 868                             _securityContext.ExecutionContext = this;
 869             }
 870         }
 871 #endif // #if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK
 872
 873
 874         public void Dispose()
 875         {
 876             if(this.IsPreAllocatedDefault)
 877                 return; //Do nothing if this is the default context
 878 #if FEATURE_CAS_POLICY
 879             if (_hostExecutionContext != null)
 880                 _hostExecutionContext.Dispose();
 881 #endif // FEATURE_CAS_POLICY
 882 #if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK
 883             if (_securityContext != null)
 884                 _securityContext.Dispose();
 885 #endif //FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK
 886         }
 887
 888         [DynamicSecurityMethod]
 889         [System.Security.SecurityCritical]  // auto-generated_required
 890         public static void Run(ExecutionContext executionContext, ContextCallback callback, Object state)
 891         {
 892             if (executionContext == null)
 893                 throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NullContext"));
 894             if (!executionContext.isNewCapture)
 895                 throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NotNewCaptureContext"));
 896
 897             Run(executionContext, callback, state, false);
 898         }
 899
 900         // This method is special from a security perspective - the VM will not allow a stack walk to
 901         // continue past the call to ExecutionContext.Run.  If you change the signature to this method, make
 902         // sure to update SecurityStackWalk::IsSpecialRunFrame in the VM to search for the new signature.
 903         [DynamicSecurityMethod]
 904         [SecurityCritical]
 905         [FriendAccessAllowed]
 906         internal static void Run(ExecutionContext executionContext, ContextCallback callback, Object state, bool preserveSyncCtx)
 907         {
 908             RunInternal(executionContext, callback, state, preserveSyncCtx);
 909         }
 910
 911         // Actual implementation of Run is here, in a non-DynamicSecurityMethod, because the JIT seems to refuse to inline callees into
 912         // a DynamicSecurityMethod.
 913         [SecurityCritical]
 914         [SuppressMessage("Microsoft.Concurrency", "CA8001", Justification = "Reviewed for thread safety")]
 915         [HandleProcessCorruptedStateExceptions]
 916         internal static void RunInternal(ExecutionContext executionContext, ContextCallback callback, Object state, bool preserveSyncCtx)
 917         {
 918             Contract.Assert(executionContext != null);
 919             if (executionContext.IsPreAllocatedDefault)
 920             {
 921                 Contract.Assert(executionContext.IsDefaultFTContext(preserveSyncCtx));
 922             }
 923             else
 924             {
 925                 Contract.Assert(executionContext.isNewCapture);
 926                 executionContext.isNewCapture = false;
 927             }
 928
 929             Thread currentThread = Thread.CurrentThread;
 930             ExecutionContextSwitcher ecsw = default(ExecutionContextSwitcher);
 931
 932             RuntimeHelpers.PrepareConstrainedRegions();
 933             try
 934             {
 935                 ExecutionContext.Reader ec = currentThread.GetExecutionContextReader();
 936                 if ( (ec.IsNull || ec.IsDefaultFTContext(preserveSyncCtx)) &&
 937     #if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK
 938                     SecurityContext.CurrentlyInDefaultFTSecurityContext(ec) &&
 939     #endif // #if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK
 940                     executionContext.IsDefaultFTContext(preserveSyncCtx) &&
 941                     ec.HasSameLocalValues(executionContext)
 942                     )
 943                 {
 944                     // Neither context is interesting, so we don't need to set the context.
 945                     // We do need to reset any changes made by the user's callback,
 946                     // so here we establish a "copy-on-write scope".  Any changes will
 947                     // result in a copy of the context being made, preserving the original
 948                     // context.
 949                     EstablishCopyOnWriteScope(currentThread, true, ref ecsw);
 950                 }
 951                 else
 952                 {
 953                     if (executionContext.IsPreAllocatedDefault)
 954                         executionContext = new ExecutionContext();
 955                     ecsw = SetExecutionContext(executionContext, preserveSyncCtx);
 956                 }
 957
 958                 //
 959                 // Call the user's callback
 960                 //
 961                 callback(state);
 962             }
 963             finally
 964             {
 965                 ecsw.Undo();
 966             }
 967         }
 968
 969         [SecurityCritical]
 970         static internal void EstablishCopyOnWriteScope(ref ExecutionContextSwitcher ecsw)
 971         {
 972             EstablishCopyOnWriteScope(Thread.CurrentThread, false, ref ecsw);
 973         }
 974
 975         [SecurityCritical]
 976         static private void EstablishCopyOnWriteScope(Thread currentThread, bool knownNullWindowsIdentity, ref ExecutionContextSwitcher ecsw)
 977         {
 978             Contract.Assert(currentThread == Thread.CurrentThread);
 979
 980             ecsw.outerEC = currentThread.GetExecutionContextReader();
 981             ecsw.outerECBelongsToScope = currentThread.ExecutionContextBelongsToCurrentScope;
 982
 983 #if !FEATURE_PAL && FEATURE_IMPERSONATION
 984             ecsw.cachedAlwaysFlowImpersonationPolicy = SecurityContext.AlwaysFlowImpersonationPolicy;
 985             if (knownNullWindowsIdentity)
 986                 Contract.Assert(SecurityContext.GetCurrentWI(ecsw.outerEC, ecsw.cachedAlwaysFlowImpersonationPolicy) == null);
 987             else
 988                 ecsw.wi = SecurityContext.GetCurrentWI(ecsw.outerEC, ecsw.cachedAlwaysFlowImpersonationPolicy);
 989             ecsw.wiIsValid = true;
 990 #endif
 991             currentThread.ExecutionContextBelongsToCurrentScope = false;
 992             ecsw.thread = currentThread;
 993         }
 994
 995
 996         // Sets the given execution context object on the thread.
 997         // Returns the previous one.
 998         [System.Security.SecurityCritical]  // auto-generated
 999         [DynamicSecurityMethodAttribute()]
1000         [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
1001 #if FEATURE_CORRUPTING_EXCEPTIONS
1002         [HandleProcessCorruptedStateExceptions] //
1003 #endif // FEATURE_CORRUPTING_EXCEPTIONS
1004         internal  static ExecutionContextSwitcher SetExecutionContext(ExecutionContext executionContext, bool preserveSyncCtx)
1005         {
1006 #if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK
1007             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
1008 #endif // #if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK
1009
1010             Contract.Assert(executionContext != null);
1011             Contract.Assert(executionContext != s_dummyDefaultEC);
1012
1013             // Set up the switcher object to return;
1014             ExecutionContextSwitcher ecsw = new ExecutionContextSwitcher();
1015
1016             Thread currentThread = Thread.CurrentThread;
1017             ExecutionContext.Reader outerEC = currentThread.GetExecutionContextReader();
1018
1019             ecsw.thread = currentThread;
1020             ecsw.outerEC = outerEC;
1021             ecsw.outerECBelongsToScope = currentThread.ExecutionContextBelongsToCurrentScope;
1022
1023             if (preserveSyncCtx)
1024                 executionContext.SynchronizationContext = outerEC.SynchronizationContext;
1025             executionContext.SynchronizationContextNoFlow = outerEC.SynchronizationContextNoFlow;
1026
1027             currentThread.SetExecutionContext(executionContext, belongsToCurrentScope: true);
1028
1029             RuntimeHelpers.PrepareConstrainedRegions();
1030             try
1031             {
1032                 OnAsyncLocalContextChanged(outerEC.DangerousGetRawExecutionContext(), executionContext);
1033
1034 #if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK
1035                 //set the security context
1036                 SecurityContext sc = executionContext.SecurityContext;
1037                 if (sc != null)
1038                 {
1039                     // non-null SC: needs to be set
1040                     SecurityContext.Reader prevSeC = outerEC.SecurityContext;
1041                     ecsw.scsw = SecurityContext.SetSecurityContext(sc, prevSeC, false, ref stackMark);
1042                 }
1043                 else if (!SecurityContext.CurrentlyInDefaultFTSecurityContext(ecsw.outerEC))
1044                 {
1045                     // null incoming SC, but we're currently not in FT: use static FTSC to set
1046                     SecurityContext.Reader prevSeC = outerEC.SecurityContext;
1047                     ecsw.scsw = SecurityContext.SetSecurityContext(SecurityContext.FullTrustSecurityContext, prevSeC, false, ref stackMark);
1048                 }
1049 #endif // #if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK
1050 #if FEATURE_CAS_POLICY
1051                 // set the Host Context
1052                 HostExecutionContext hostContext = executionContext.HostExecutionContext;
1053                 if (hostContext != null)
1054                 {
1055                     ecsw.hecsw = HostExecutionContextManager.SetHostExecutionContextInternal(hostContext);
1056                 }
1057 #endif // FEATURE_CAS_POLICY
1058             }
1059             catch
1060             {
1061                 ecsw.UndoNoThrow();
1062                 throw;
1063             }
1064             return ecsw;
1065         }
1066
1067         //
1068         // Public CreateCopy.  Used to copy captured ExecutionContexts so they can be reused multiple times.
1069         // This should only copy the portion of the context that we actually capture.
1070         //
1071         [SecuritySafeCritical]
1072         public ExecutionContext CreateCopy()
1073         {
1074             if (!isNewCapture)
1075             {
1076                 throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_CannotCopyUsedContext"));
1077             }
1078             ExecutionContext ec = new ExecutionContext();
1079             ec.isNewCapture = true;
1080             ec._syncContext = _syncContext == null ? null : _syncContext.CreateCopy();
1081             ec._localValues = _localValues;
1082             ec._localChangeNotifications = _localChangeNotifications;
1083 #if FEATURE_CAS_POLICY
1084             // capture the host execution context
1085             ec._hostExecutionContext = _hostExecutionContext == null ? null : _hostExecutionContext.CreateCopy();
1086 #endif // FEATURE_CAS_POLICY
1087 #if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK
1088             if (_securityContext != null)
1089             {
1090                 ec._securityContext = _securityContext.CreateCopy();
1091                 ec._securityContext.ExecutionContext = ec;
1092             }
1093 #endif // #if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK
1094
1095 #if FEATURE_REMOTING
1096             if (this._logicalCallContext != null)
1097                 ec.LogicalCallContext = (LogicalCallContext)this.LogicalCallContext.Clone();
1098
1099             Contract.Assert(this._illogicalCallContext == null);
1100 #endif // #if FEATURE_REMOTING
1101
1102             return ec;
1103         }
1104
1105         //
1106         // Creates a complete copy, used for copy-on-write.
1107         //
1108         [SecuritySafeCritical]
1109         internal ExecutionContext CreateMutableCopy()
1110         {
1111             Contract.Assert(!this.isNewCapture);
1112
1113             ExecutionContext ec = new ExecutionContext();
1114
1115             // We don't deep-copy the SyncCtx, since we're still in the same context after copy-on-write.
1116             ec._syncContext = this._syncContext;
1117             ec._syncContextNoFlow = this._syncContextNoFlow;
1118
1119 #if FEATURE_CAS_POLICY
1120             // capture the host execution context
1121             ec._hostExecutionContext = this._hostExecutionContext == null ? null : _hostExecutionContext.CreateCopy();
1122 #endif // FEATURE_CAS_POLICY
1123
1124 #if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK
1125             if (_securityContext != null)
1126             {
1127                 ec._securityContext = this._securityContext.CreateMutableCopy();
1128                 ec._securityContext.ExecutionContext = ec;
1129             }
1130 #endif // #if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK
1131
1132 #if FEATURE_REMOTING
1133             if (this._logicalCallContext != null)
1134                 ec.LogicalCallContext = (LogicalCallContext)this.LogicalCallContext.Clone();
1135
1136             if (this._illogicalCallContext != null)
1137                 ec.IllogicalCallContext = (IllogicalCallContext)this.IllogicalCallContext.CreateCopy();
1138 #endif // #if FEATURE_REMOTING
1139
1140             ec._localValues = this._localValues;
1141             ec._localChangeNotifications = this._localChangeNotifications;
1142             ec.isFlowSuppressed = this.isFlowSuppressed;
1143
1144             return ec;
1145         }
1146
1147         [System.Security.SecurityCritical]  // auto-generated_required
1148         public static AsyncFlowControl SuppressFlow()
1149         {
1150             if (IsFlowSuppressed())
1151             {
1152                 throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_CannotSupressFlowMultipleTimes"));
1153             }
1154             Contract.EndContractBlock();
1155             AsyncFlowControl afc = new AsyncFlowControl();
1156             afc.Setup();
1157             return afc;
1158         }
1159
1160         [SecuritySafeCritical]
1161         public static void RestoreFlow()
1162         {
1163             ExecutionContext ec = Thread.CurrentThread.GetMutableExecutionContext();
1164             if (!ec.isFlowSuppressed)
1165             {
1166                 throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_CannotRestoreUnsupressedFlow"));
1167             }
1168             ec.isFlowSuppressed = false;
1169         }
1170
1171         [Pure]
1172         public static bool IsFlowSuppressed()
1173         {
1174             return Thread.CurrentThread.GetExecutionContextReader().IsFlowSuppressed;
1175         }
1176
1177         [System.Security.SecuritySafeCritical]  // auto-generated
1178         [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
1179         public static ExecutionContext Capture()
1180         {
1181             // set up a stack mark for finding the caller
1182             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
1183             return ExecutionContext.Capture(ref stackMark, CaptureOptions.None);
1184         }
1185
1186         //
1187         // Captures an ExecutionContext with optimization for the "default" case, and captures a "null" synchronization context.
1188         // When calling ExecutionContext.Run on the returned context, specify ignoreSyncCtx = true
1189         //
1190         [System.Security.SecuritySafeCritical]  // auto-generated
1191         [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
1192         [FriendAccessAllowed]
1193         internal static ExecutionContext FastCapture()
1194         {
1195             // set up a stack mark for finding the caller
1196             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
1197             return ExecutionContext.Capture(ref stackMark, CaptureOptions.IgnoreSyncCtx | CaptureOptions.OptimizeDefaultCase);
1198         }
1199
1200
1201         [Flags]
1202         internal enum CaptureOptions
1203         {
1204             None = 0x00,
1205
1206             IgnoreSyncCtx = 0x01,       //Don't flow SynchronizationContext
1207
1208             OptimizeDefaultCase = 0x02, //Faster in the typical case, but can't show the result to users
1209                                         // because they could modify the shared default EC.
1210                                         // Use this only if you won't be exposing the captured EC to users.
1211         }
1212
1213     // internal helper to capture the current execution context using a passed in stack mark
1214         [System.Security.SecurityCritical]  // auto-generated
1215         static internal ExecutionContext Capture(ref StackCrawlMark stackMark, CaptureOptions options)
1216         {
1217             ExecutionContext.Reader ecCurrent = Thread.CurrentThread.GetExecutionContextReader();
1218
1219             // check to see if Flow is suppressed
1220             if (ecCurrent.IsFlowSuppressed)
1221                 return null;
1222
1223             //
1224             // Attempt to capture context.  There may be nothing to capture...
1225             //
1226
1227 #if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK
1228             // capture the security context
1229             SecurityContext secCtxNew = SecurityContext.Capture(ecCurrent, ref stackMark);
1230 #endif // #if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK
1231 #if FEATURE_CAS_POLICY
1232              // capture the host execution context
1233             HostExecutionContext hostCtxNew = HostExecutionContextManager.CaptureHostExecutionContext();
1234 #endif // FEATURE_CAS_POLICY
1235
1236             SynchronizationContext syncCtxNew = null;
1237
1238 #if FEATURE_REMOTING
1239             LogicalCallContext logCtxNew = null;
1240 #endif
1241
1242             if (!ecCurrent.IsNull)
1243             {
1244                 // capture the sync context
1245                 if (0 == (options & CaptureOptions.IgnoreSyncCtx))
1246                     syncCtxNew = (ecCurrent.SynchronizationContext == null) ? null : ecCurrent.SynchronizationContext.CreateCopy();
1247
1248 #if FEATURE_REMOTING
1249                 // copy over the Logical Call Context
1250                 if (ecCurrent.LogicalCallContext.HasInfo)
1251                     logCtxNew = ecCurrent.LogicalCallContext.Clone();
1252 #endif // #if FEATURE_REMOTING
1253             }
1254
1255             Dictionary<IAsyncLocal, object> localValues = null;
1256             List<IAsyncLocal> localChangeNotifications = null;
1257             if (!ecCurrent.IsNull)
1258             {
1259                 localValues = ecCurrent.DangerousGetRawExecutionContext()._localValues;
1260                 localChangeNotifications = ecCurrent.DangerousGetRawExecutionContext()._localChangeNotifications;
1261             }
1262
1263             //
1264             // If we didn't get anything but defaults, and we're allowed to return the
1265             // dummy default EC, don't bother allocating a new context.
1266             //
1267             if (0 != (options & CaptureOptions.OptimizeDefaultCase) &&
1268 #if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK
1269                 secCtxNew == null &&
1270 #endif
1271 #if FEATURE_CAS_POLICY
1272                 hostCtxNew == null &&
1273 #endif // FEATURE_CAS_POLICY
1274                 syncCtxNew == null &&
1275 #if FEATURE_REMOTING
1276                 (logCtxNew == null || !logCtxNew.HasInfo) &&
1277 #endif // #if FEATURE_REMOTING
1278                 localValues == null &&
1279                 localChangeNotifications == null
1280                 )
1281             {
1282                 return s_dummyDefaultEC;
1283             }
1284
1285             //
1286             // Allocate the new context, and fill it in.
1287             //
1288             ExecutionContext ecNew = new ExecutionContext();
1289 #if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK
1290             ecNew.SecurityContext = secCtxNew;
1291             if (ecNew.SecurityContext != null)
1292                 ecNew.SecurityContext.ExecutionContext = ecNew;
1293 #endif
1294 #if FEATURE_CAS_POLICY
1295             ecNew._hostExecutionContext = hostCtxNew;
1296 #endif // FEATURE_CAS_POLICY
1297             ecNew._syncContext = syncCtxNew;
1298 #if FEATURE_REMOTING
1299             ecNew.LogicalCallContext = logCtxNew;
1300 #endif // #if FEATURE_REMOTING
1301             ecNew._localValues = localValues;
1302             ecNew._localChangeNotifications = localChangeNotifications;
1303             ecNew.isNewCapture = true;
1304
1305             return ecNew;
1306         }
1307
1308         //
1309         // Implementation of ISerializable
1310         //
1311
1312         [System.Security.SecurityCritical]  // auto-generated_required
1313         public void GetObjectData(SerializationInfo info, StreamingContext context)
1314         {
1315             if (info==null)
1316                 throw new ArgumentNullException("info");
1317             Contract.EndContractBlock();
1318
1319 #if FEATURE_REMOTING
1320             if (_logicalCallContext != null)
1321             {
1322                 info.AddValue("LogicalCallContext", _logicalCallContext, typeof(LogicalCallContext));
1323             }
1324 #endif // #if FEATURE_REMOTING
1325         }
1326
1327         [System.Security.SecurityCritical]  // auto-generated
1328         private ExecutionContext(SerializationInfo info, StreamingContext context)
1329         {
1330             SerializationInfoEnumerator e = info.GetEnumerator();
1331             while (e.MoveNext())
1332             {
1333 #if FEATURE_REMOTING
1334                 if (e.Name.Equals("LogicalCallContext"))
1335                 {
1336                     _logicalCallContext = (LogicalCallContext) e.Value;
1337                 }
1338 #endif // #if FEATURE_REMOTING
1339             }
1340         } // ObjRef .ctor
1341
1342
1343         [System.Security.SecurityCritical]  // auto-generated
1344         internal bool IsDefaultFTContext(bool ignoreSyncCtx)
1345         {
1346 #if FEATURE_CAS_POLICY
1347             if (_hostExecutionContext != null)
1348                 return false;
1349 #endif // FEATURE_CAS_POLICY
1350             if (!ignoreSyncCtx && _syncContext != null)
1351                 return false;
1352 #if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK
1353             if (_securityContext != null && !_securityContext.IsDefaultFTSecurityContext())
1354                 return false;
1355 #endif //#if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK
1356 #if FEATURE_REMOTING
1357             if (_logicalCallContext != null && _logicalCallContext.HasInfo)
1358                 return false;
1359             if (_illogicalCallContext != null && _illogicalCallContext.HasUserData)
1360                 return false;
1361 #endif //#if FEATURE_REMOTING
1362             return true;
1363         }
1364     } // class ExecutionContext
1365
1366 #endif //FEATURE_CORECLR
1367 }
1368
1369