Code:
/ 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / cdf / src / System.Runtime.DurableInstancing / System / Runtime / Fx.cs / 1305376 / Fx.cs
//------------------------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//-----------------------------------------------------------------------------
namespace System.Runtime
{
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.ConstrainedExecution;
using System.Runtime.Diagnostics;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Security;
using System.Security.Permissions;
using System.Threading;
using System.Transactions;
using Microsoft.Win32;
static class Fx
{
const string defaultEventSource = "System.Runtime";
#if DEBUG
const string WinFXRegistryKey = @"SOFTWARE\Microsoft\NET Framework Setup\NDP";
const string WcfRegistryKey = WinFXRegistryKey + @"\CDF\v4.0\Debug";
const string AssertsFailFastName = "AssertsFailFast";
const string BreakOnExceptionTypesName = "BreakOnExceptionTypes";
const string FastDebugName = "FastDebug";
const string StealthDebuggerName = "StealthDebugger";
static bool breakOnExceptionTypesRetrieved;
static Type[] breakOnExceptionTypesCache;
static bool fastDebugRetrieved;
static bool fastDebugCache;
static bool stealthDebuggerRetrieved;
static bool stealthDebuggerCache;
#endif
static ExceptionTrace exceptionTrace;
static DiagnosticTrace diagnosticTrace;
[Fx.Tag.SecurityNote(Critical="This delegate is called from within a ConstrainedExecutionRegion, must not be settable from PT code")]
[SecurityCritical]
static ExceptionHandler asynchronousThreadExceptionHandler;
public static ExceptionTrace Exception
{
get
{
if (exceptionTrace == null)
{
// don't need a lock here since a true singleton is not required
exceptionTrace = new ExceptionTrace(defaultEventSource);
}
return exceptionTrace;
}
}
public static DiagnosticTrace Trace
{
get
{
if (diagnosticTrace == null)
{
diagnosticTrace = InitializeTracing();
}
return diagnosticTrace;
}
}
[Fx.Tag.SecurityNote(Critical = "Accesses SecurityCritical field EtwProvider",
Safe = "Doesn't leak info\\resources")]
[SecuritySafeCritical]
[SuppressMessage(FxCop.Category.ReliabilityBasic, FxCop.Rule.UseNewGuidHelperRule,
Justification = "This is a method that creates ETW provider passing Guid Provider ID.")]
static DiagnosticTrace InitializeTracing()
{
DiagnosticTrace trace = new DiagnosticTrace(defaultEventSource, DiagnosticTrace.DefaultEtwProviderId);
return trace;
}
public static ExceptionHandler AsynchronousThreadExceptionHandler
{
[Fx.Tag.SecurityNote(Critical="access critical field", Safe="ok for get-only access")]
[SecuritySafeCritical]
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
get
{
return Fx.asynchronousThreadExceptionHandler;
}
[Fx.Tag.SecurityNote(Critical="sets a critical field")]
[SecurityCritical]
set
{
Fx.asynchronousThreadExceptionHandler = value;
}
}
// Do not call the parameter "message" or else FxCop thinks it should be localized.
[Conditional("DEBUG")]
public static void Assert(bool condition, string description)
{
if (!condition)
{
Assert(description);
}
}
[Conditional("DEBUG")]
public static void Assert(string description)
{
AssertHelper.FireAssert(description);
}
public static void AssertAndThrow(bool condition, string description)
{
if (!condition)
{
AssertAndThrow(description);
}
}
[MethodImpl(MethodImplOptions.NoInlining)]
public static Exception AssertAndThrow(string description)
{
Fx.Assert(description);
TraceCore.ShipAssertExceptionMessage(Trace, description);
throw new InternalException(description);
}
public static void AssertAndThrowFatal(bool condition, string description)
{
if (!condition)
{
AssertAndThrowFatal(description);
}
}
[MethodImpl(MethodImplOptions.NoInlining)]
public static Exception AssertAndThrowFatal(string description)
{
Fx.Assert(description);
TraceCore.ShipAssertExceptionMessage(Trace, description);
throw new FatalInternalException(description);
}
public static void AssertAndFailFast(bool condition, string description)
{
if (!condition)
{
AssertAndFailFast(description);
}
}
// This never returns. The Exception return type lets you write 'throw AssertAndFailFast()' which tells the compiler/tools that
// execution stops.
[Fx.Tag.SecurityNote(Critical = "Calls into critical method Environment.FailFast",
Safe="The side affect of the app crashing is actually intended here")]
[SecuritySafeCritical]
[MethodImpl(MethodImplOptions.NoInlining)]
public static Exception AssertAndFailFast(string description)
{
Fx.Assert(description);
string failFastMessage = SRCore.FailFastMessage(description);
// The catch is here to force the finally to run, as finallys don't run until the stack walk gets to a catch.
// The catch makes sure that the finally will run before the stack-walk leaves the frame, but the code inside is impossible to reach.
try
{
try
{
Fx.Exception.TraceFailFast(failFastMessage);
}
finally
{
Environment.FailFast(failFastMessage);
}
}
catch
{
throw;
}
return null; // we'll never get here since we've just fail-fasted
}
public static void ThrowIfTransactionAbortedOrInDoubt(Transaction transaction)
{
if (transaction == null)
{
return;
}
if (transaction.TransactionInformation.Status == TransactionStatus.Aborted || transaction.TransactionInformation.Status == TransactionStatus.InDoubt)
{
//This will throw TransactionAbortedException/TransactionInDoubtException with corresponding inner exception if any
using (TransactionScope scope = new TransactionScope(transaction))
{
//empty
}
}
}
public static bool IsFatal(Exception exception)
{
while (exception != null)
{
if (exception is FatalException ||
(exception is OutOfMemoryException && !(exception is InsufficientMemoryException)) ||
exception is ThreadAbortException ||
exception is FatalInternalException)
{
return true;
}
// These exceptions aren't themselves fatal, but since the CLR uses them to wrap other exceptions,
// we want to check to see whether they've been used to wrap a fatal exception. If so, then they
// count as fatal.
if (exception is TypeInitializationException ||
exception is TargetInvocationException)
{
exception = exception.InnerException;
}
else
{
break;
}
}
return false;
}
// This method should be only used for debug build.
internal static bool AssertsFailFast
{
get
{
#if DEBUG
object value;
return TryGetDebugSwitch(Fx.AssertsFailFastName, out value) &&
typeof(int).IsAssignableFrom(value.GetType()) && ((int)value) != 0;
#else
return false;
#endif
}
}
// This property should be only used for debug build.
internal static Type[] BreakOnExceptionTypes
{
get
{
#if DEBUG
if (!Fx.breakOnExceptionTypesRetrieved)
{
object value;
if (TryGetDebugSwitch(Fx.BreakOnExceptionTypesName, out value))
{
string[] typeNames = value as string[];
if (typeNames != null && typeNames.Length > 0)
{
List types = new List(typeNames.Length);
for (int i = 0; i < typeNames.Length; i++)
{
types.Add(Type.GetType(typeNames[i], false));
}
if (types.Count != 0)
{
Fx.breakOnExceptionTypesCache = types.ToArray();
}
}
}
Fx.breakOnExceptionTypesRetrieved = true;
}
return Fx.breakOnExceptionTypesCache;
#else
return null;
#endif
}
}
// This property should be only used for debug build.
internal static bool FastDebug
{
get
{
#if DEBUG
if (!Fx.fastDebugRetrieved)
{
object value;
if (TryGetDebugSwitch(Fx.FastDebugName, out value))
{
Fx.fastDebugCache = typeof(int).IsAssignableFrom(value.GetType()) && ((int)value) != 0;
}
Fx.fastDebugRetrieved = true;
}
return Fx.fastDebugCache;
#else
return false;
#endif
}
}
// This property should be only used for debug build.
internal static bool StealthDebugger
{
get
{
#if DEBUG
if (!Fx.stealthDebuggerRetrieved)
{
object value;
if (TryGetDebugSwitch(Fx.StealthDebuggerName, out value))
{
Fx.stealthDebuggerCache = typeof(int).IsAssignableFrom(value.GetType()) && ((int)value) != 0;
}
Fx.stealthDebuggerRetrieved = true;
}
return Fx.stealthDebuggerCache;
#else
return false;
#endif
}
}
#if DEBUG
static bool TryGetDebugSwitch(string name, out object value)
{
value = null;
try
{
RegistryKey key = Registry.LocalMachine.OpenSubKey(Fx.WcfRegistryKey);
if (key != null)
{
using (key)
{
value = key.GetValue(name);
}
}
}
catch (SecurityException)
{
// This debug-only code shouldn't trace.
}
return value != null;
}
#endif
public static AsyncCallback ThunkCallback(AsyncCallback callback)
{
return (new AsyncThunk(callback)).ThunkFrame;
}
public static WaitCallback ThunkCallback(WaitCallback callback)
{
return (new WaitThunk(callback)).ThunkFrame;
}
public static TimerCallback ThunkCallback(TimerCallback callback)
{
return (new TimerThunk(callback)).ThunkFrame;
}
public static WaitOrTimerCallback ThunkCallback(WaitOrTimerCallback callback)
{
return (new WaitOrTimerThunk(callback)).ThunkFrame;
}
public static SendOrPostCallback ThunkCallback(SendOrPostCallback callback)
{
return (new SendOrPostThunk(callback)).ThunkFrame;
}
[Fx.Tag.SecurityNote(Critical="Construct the unsafe object IOCompletionThunk")]
[SecurityCritical]
public static IOCompletionCallback ThunkCallback(IOCompletionCallback callback)
{
return (new IOCompletionThunk(callback)).ThunkFrame;
}
[SuppressMessage(FxCop.Category.ReliabilityBasic, FxCop.Rule.UseNewGuidHelperRule,
Justification = "These are the core methods that should be used for all other Guid(string) calls.")]
public static Guid CreateGuid(string guidString)
{
bool success = false;
Guid result = Guid.Empty;
try
{
result = new Guid(guidString);
success = true;
}
finally
{
if (!success)
{
AssertAndThrow("Creation of the Guid failed.");
}
}
return result;
}
[SuppressMessage(FxCop.Category.ReliabilityBasic, FxCop.Rule.UseNewGuidHelperRule,
Justification = "These are the core methods that should be used for all other Guid(string) calls.")]
public static bool TryCreateGuid(string guidString, out Guid result)
{
bool success = false;
result = Guid.Empty;
try
{
result = new Guid(guidString);
success = true;
}
catch (ArgumentException)
{
// ---- this
}
catch (FormatException)
{
// ---- this
}
catch (OverflowException)
{
// ---- this
}
return success;
}
public static byte[] AllocateByteArray(int size)
{
try
{
// Safe to catch OOM from this as long as the ONLY thing it does is a simple allocation of a primitive type (no method calls).
return new byte[size];
}
catch (OutOfMemoryException exception)
{
// Convert OOM into an exception that can be safely handled by higher layers.
throw Fx.Exception.AsError(
new InsufficientMemoryException(SRCore.BufferAllocationFailed(size), exception));
}
}
public static char[] AllocateCharArray(int size)
{
try
{
// Safe to catch OOM from this as long as the ONLY thing it does is a simple allocation of a primitive type (no method calls).
return new char[size];
}
catch (OutOfMemoryException exception)
{
// Convert OOM into an exception that can be safely handled by higher layers.
throw Fx.Exception.AsError(
new InsufficientMemoryException(SRCore.BufferAllocationFailed(size * sizeof(char)), exception));
}
}
// If the transaction has aborted then we switch over to a new transaction
// which we will immediately abort after setting Transaction.Current
public static TransactionScope CreateTransactionScope(Transaction transaction)
{
try
{
return transaction == null ? null : new TransactionScope(transaction);
}
catch (TransactionAbortedException)
{
CommittableTransaction tempTransaction = new CommittableTransaction();
try
{
return new TransactionScope(tempTransaction.Clone());
}
finally
{
tempTransaction.Rollback();
}
}
}
public static void CompleteTransactionScope(ref TransactionScope scope)
{
TransactionScope localScope = scope;
if (localScope != null)
{
scope = null;
try
{
localScope.Complete();
}
finally
{
localScope.Dispose();
}
}
}
[SuppressMessage(FxCop.Category.Design, FxCop.Rule.DoNotCatchGeneralExceptionTypes,
Justification = "Don't want to hide the exception which is about to crash the process.")]
[Fx.Tag.SecurityNote(Miscellaneous = "Must not call into PT code as it is called within a CER.")]
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
static void TraceExceptionNoThrow(Exception exception)
{
try
{
// This call exits the CER. However, when still inside a catch, normal ThreadAbort is prevented.
// Rude ThreadAbort will still be allowed to terminate processing.
Fx.Exception.TraceUnhandledException(exception);
}
catch
{
// This empty catch is only acceptable because we are a) in a CER and b) processing an exception
// which is about to crash the process anyway.
}
}
[SuppressMessage(FxCop.Category.Design, FxCop.Rule.DoNotCatchGeneralExceptionTypes,
Justification = "Don't want to hide the exception which is about to crash the process.")]
[SuppressMessage(FxCop.Category.ReliabilityBasic, FxCop.Rule.IsFatalRule,
Justification = "Don't want to hide the exception which is about to crash the process.")]
[Fx.Tag.SecurityNote(Miscellaneous = "Must not call into PT code as it is called within a CER.")]
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
static bool HandleAtThreadBase(Exception exception)
{
// This area is too sensitive to do anything but return.
if (exception == null)
{
Fx.Assert("Null exception in HandleAtThreadBase.");
return false;
}
TraceExceptionNoThrow(exception);
try
{
ExceptionHandler handler = Fx.AsynchronousThreadExceptionHandler;
return handler == null ? false : handler.HandleException(exception);
}
catch (Exception secondException)
{
// Don't let a new exception hide the original exception.
TraceExceptionNoThrow(secondException);
}
return false;
}
public abstract class ExceptionHandler
{
[Fx.Tag.SecurityNote(Miscellaneous = "Must not call into PT code as it is called within a CER.")]
public abstract bool HandleException(Exception exception);
}
public static class Tag
{
public enum CacheAttrition
{
None,
ElementOnTimer,
// A finalizer/WeakReference based cache, where the elements are held by WeakReferences (or hold an
// inner object by a WeakReference), and the weakly-referenced object has a finalizer which cleans the
// item from the cache.
ElementOnGC,
// A cache that provides a per-element token, delegate, interface, or other piece of context that can
// be used to remove the element (such as IDisposable).
ElementOnCallback,
FullPurgeOnTimer,
FullPurgeOnEachAccess,
PartialPurgeOnTimer,
PartialPurgeOnEachAccess,
}
public enum ThrottleAction
{
Reject,
Pause,
}
public enum ThrottleMetric
{
Count,
Rate,
Other,
}
public enum Location
{
InProcess,
OutOfProcess,
LocalSystem,
LocalOrRemoteSystem, // as in a file that might live on a share
RemoteSystem,
}
public enum SynchronizationKind
{
LockStatement,
MonitorWait,
MonitorExplicit,
InterlockedNoSpin,
InterlockedWithSpin,
// Same as LockStatement if the field type is object.
FromFieldType,
}
[Flags]
public enum BlocksUsing
{
MonitorEnter,
MonitorWait,
ManualResetEvent,
AutoResetEvent,
AsyncResult,
IAsyncResult,
PInvoke,
InputQueue,
ThreadNeutralSemaphore,
PrivatePrimitive,
OtherInternalPrimitive,
OtherFrameworkPrimitive,
OtherInterop,
Other,
NonBlocking, // For use by non-blocking SynchronizationPrimitives such as IOThreadScheduler
}
public static class Strings
{
internal const string ExternallyManaged = "externally managed";
internal const string AppDomain = "AppDomain";
internal const string DeclaringInstance = "instance of declaring class";
internal const string Unbounded = "unbounded";
internal const string Infinite = "infinite";
}
[AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor | AttributeTargets.Property | AttributeTargets.Class,
AllowMultiple = true, Inherited = false)]
[Conditional("DEBUG")]
public sealed class FriendAccessAllowedAttribute : Attribute
{
public FriendAccessAllowedAttribute(string assemblyName) :
base()
{
this.AssemblyName = assemblyName;
}
public string AssemblyName { get; set; }
}
public static class Throws
{
[AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor,
AllowMultiple = true, Inherited = false)]
[Conditional("CODE_ANALYSIS_CDF")]
public sealed class TimeoutAttribute : ThrowsAttribute
{
public TimeoutAttribute() :
this("The operation timed out.")
{
}
public TimeoutAttribute(string diagnosis) :
base(typeof(TimeoutException), diagnosis)
{
}
}
}
[AttributeUsage(AttributeTargets.Field)]
[Conditional("CODE_ANALYSIS_CDF")]
public sealed class CacheAttribute : Attribute
{
readonly Type elementType;
readonly CacheAttrition cacheAttrition;
public CacheAttribute(Type elementType, CacheAttrition cacheAttrition)
{
Scope = Strings.DeclaringInstance;
SizeLimit = Strings.Unbounded;
Timeout = Strings.Infinite;
if (elementType == null)
{
throw Fx.Exception.ArgumentNull("elementType");
}
this.elementType = elementType;
this.cacheAttrition = cacheAttrition;
}
public Type ElementType
{
get
{
return this.elementType;
}
}
public CacheAttrition CacheAttrition
{
get
{
return this.cacheAttrition;
}
}
public string Scope { get; set; }
public string SizeLimit { get; set; }
public string Timeout { get; set; }
}
[AttributeUsage(AttributeTargets.Field)]
[Conditional("CODE_ANALYSIS_CDF")]
public sealed class QueueAttribute : Attribute
{
readonly Type elementType;
public QueueAttribute(Type elementType)
{
Scope = Strings.DeclaringInstance;
SizeLimit = Strings.Unbounded;
if (elementType == null)
{
throw Fx.Exception.ArgumentNull("elementType");
}
this.elementType = elementType;
}
public Type ElementType
{
get
{
return this.elementType;
}
}
public string Scope { get; set; }
public string SizeLimit { get; set; }
public bool StaleElementsRemovedImmediately { get; set; }
public bool EnqueueThrowsIfFull { get; set; }
}
[AttributeUsage(AttributeTargets.Field)]
[Conditional("CODE_ANALYSIS_CDF")]
public sealed class ThrottleAttribute : Attribute
{
readonly ThrottleAction throttleAction;
readonly ThrottleMetric throttleMetric;
readonly string limit;
public ThrottleAttribute(ThrottleAction throttleAction, ThrottleMetric throttleMetric, string limit)
{
Scope = Strings.AppDomain;
if (string.IsNullOrEmpty(limit))
{
throw Fx.Exception.ArgumentNullOrEmpty("limit");
}
this.throttleAction = throttleAction;
this.throttleMetric = throttleMetric;
this.limit = limit;
}
public ThrottleAction ThrottleAction
{
get
{
return this.throttleAction;
}
}
public ThrottleMetric ThrottleMetric
{
get
{
return this.throttleMetric;
}
}
public string Limit
{
get
{
return this.limit;
}
}
public string Scope
{
get; set;
}
}
[AttributeUsage(AttributeTargets.Field | AttributeTargets.Method | AttributeTargets.Constructor,
AllowMultiple = true, Inherited = false)]
[Conditional("CODE_ANALYSIS_CDF")]
public sealed class ExternalResourceAttribute : Attribute
{
readonly Location location;
readonly string description;
public ExternalResourceAttribute(Location location, string description)
{
this.location = location;
this.description = description;
}
public Location Location
{
get
{
return this.location;
}
}
public string Description
{
get
{
return this.description;
}
}
}
// Set on a class when that class uses lock (this) - acts as though it were on a field
// private object this;
[AttributeUsage(AttributeTargets.Field | AttributeTargets.Class, Inherited = false)]
[Conditional("CODE_ANALYSIS_CDF")]
public sealed class SynchronizationObjectAttribute : Attribute
{
public SynchronizationObjectAttribute()
{
Blocking = true;
Scope = Strings.DeclaringInstance;
Kind = SynchronizationKind.FromFieldType;
}
public bool Blocking { get; set; }
public string Scope { get; set; }
public SynchronizationKind Kind { get; set; }
}
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, Inherited = true)]
[Conditional("CODE_ANALYSIS_CDF")]
public sealed class SynchronizationPrimitiveAttribute : Attribute
{
readonly BlocksUsing blocksUsing;
public SynchronizationPrimitiveAttribute(BlocksUsing blocksUsing)
{
this.blocksUsing = blocksUsing;
}
public BlocksUsing BlocksUsing
{
get
{
return this.blocksUsing;
}
}
public bool SupportsAsync { get; set; }
public bool Spins { get; set; }
public string ReleaseMethod { get; set; }
}
[AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor, Inherited = false)]
[Conditional("CODE_ANALYSIS_CDF")]
public sealed class BlockingAttribute : Attribute
{
public BlockingAttribute()
{
}
public string CancelMethod { get; set; }
public Type CancelDeclaringType { get; set; }
public string Conditional { get; set; }
}
// Sometime a method will call a conditionally-blocking method in such a way that it is guaranteed
// not to block (i.e. the condition can be Asserted false). Such a method can be marked as
// GuaranteeNonBlocking as an assertion that the method doesn't block despite calling a blocking method.
//
// Methods that don't call blocking methods and aren't marked as Blocking are assumed not to block, so
// they do not require this attribute.
[AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor, Inherited = false)]
[Conditional("CODE_ANALYSIS_CDF")]
public sealed class GuaranteeNonBlockingAttribute : Attribute
{
public GuaranteeNonBlockingAttribute()
{
}
}
[AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor, Inherited = false)]
[Conditional("CODE_ANALYSIS_CDF")]
public sealed class NonThrowingAttribute : Attribute
{
public NonThrowingAttribute()
{
}
}
[SuppressMessage(FxCop.Category.Performance, "CA1813:AvoidUnsealedAttributes",
Justification = "This is intended to be an attribute heirarchy. It does not affect product perf.")]
[AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor,
AllowMultiple = true, Inherited = false)]
[Conditional("CODE_ANALYSIS_CDF")]
public class ThrowsAttribute : Attribute
{
readonly Type exceptionType;
readonly string diagnosis;
public ThrowsAttribute(Type exceptionType, string diagnosis)
{
if (exceptionType == null)
{
throw Fx.Exception.ArgumentNull("exceptionType");
}
if (string.IsNullOrEmpty(diagnosis))
{
throw Fx.Exception.ArgumentNullOrEmpty("diagnosis");
}
this.exceptionType = exceptionType;
this.diagnosis = diagnosis;
}
public Type ExceptionType
{
get
{
return this.exceptionType;
}
}
public string Diagnosis
{
get
{
return this.diagnosis;
}
}
}
[AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor, Inherited = false)]
[Conditional("CODE_ANALYSIS_CDF")]
public sealed class InheritThrowsAttribute : Attribute
{
public InheritThrowsAttribute()
{
}
public Type FromDeclaringType { get; set; }
public string From { get; set; }
}
[AttributeUsage(AttributeTargets.Property, AllowMultiple = false, Inherited = true)]
[Conditional("CODE_ANALYSIS_CDF")]
public sealed class KnownXamlExternalAttribute : Attribute
{
public KnownXamlExternalAttribute()
{
}
}
[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class | AttributeTargets.Struct, AllowMultiple = false, Inherited = false)]
[Conditional("CODE_ANALYSIS_CDF")]
public sealed class XamlVisibleAttribute : Attribute
{
public XamlVisibleAttribute()
: this(true)
{
}
public XamlVisibleAttribute(bool visible)
{
this.Visible = visible;
}
public bool Visible
{
get;
private set;
}
}
[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class |
AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method |
AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface |
AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
[Conditional("CODE_ANALYSIS_CDF")]
public sealed class SecurityNoteAttribute : Attribute
{
public SecurityNoteAttribute()
{
}
public string Critical
{
get;
set;
}
public string Safe
{
get;
set;
}
public string Miscellaneous
{
get;
set;
}
}
}
abstract class Thunk where T : class
{
[Fx.Tag.SecurityNote(Critical = "Make these safe to use in SecurityCritical contexts.")]
[SecurityCritical]
T callback;
[Fx.Tag.SecurityNote(Critical = "Accesses critical field.", Safe = "Data provided by caller.")]
[SecuritySafeCritical]
protected Thunk(T callback)
{
this.callback = callback;
}
internal T Callback
{
[Fx.Tag.SecurityNote(Critical = "Accesses critical field.", Safe = "Data is not privileged.")]
[SecuritySafeCritical]
get
{
return this.callback;
}
}
}
sealed class AsyncThunk : Thunk
{
public AsyncThunk(AsyncCallback callback) : base(callback)
{
}
public AsyncCallback ThunkFrame
{
get
{
return new AsyncCallback(UnhandledExceptionFrame);
}
}
[Fx.Tag.SecurityNote(Critical="Calls PrepareConstrainedRegions which has a LinkDemand",
Safe="Guaranteed not to call into PT user code from the finally.")]
[SecuritySafeCritical]
void UnhandledExceptionFrame(IAsyncResult result)
{
RuntimeHelpers.PrepareConstrainedRegions();
try
{
Callback(result);
}
catch (Exception exception)
{
if (!Fx.HandleAtThreadBase(exception))
{
throw;
}
}
}
}
sealed class WaitThunk : Thunk
{
public WaitThunk(WaitCallback callback) : base(callback)
{
}
public WaitCallback ThunkFrame
{
get
{
return new WaitCallback(UnhandledExceptionFrame);
}
}
[Fx.Tag.SecurityNote(Critical="Calls PrepareConstrainedRegions which has a LinkDemand",
Safe="Guaranteed not to call into PT user code from the finally.")]
[SecuritySafeCritical]
void UnhandledExceptionFrame(object state)
{
RuntimeHelpers.PrepareConstrainedRegions();
try
{
Callback(state);
}
catch (Exception exception)
{
if (!Fx.HandleAtThreadBase(exception))
{
throw;
}
}
}
}
sealed class TimerThunk : Thunk
{
public TimerThunk(TimerCallback callback) : base(callback)
{
}
public TimerCallback ThunkFrame
{
get
{
return new TimerCallback(UnhandledExceptionFrame);
}
}
[Fx.Tag.SecurityNote(Critical="Calls PrepareConstrainedRegions which has a LinkDemand",
Safe="Guaranteed not to call into PT user code from the finally.")]
[SecuritySafeCritical]
void UnhandledExceptionFrame(object state)
{
RuntimeHelpers.PrepareConstrainedRegions();
try
{
Callback(state);
}
catch (Exception exception)
{
if (!Fx.HandleAtThreadBase(exception))
{
throw;
}
}
}
}
sealed class WaitOrTimerThunk : Thunk
{
public WaitOrTimerThunk(WaitOrTimerCallback callback) : base(callback)
{
}
public WaitOrTimerCallback ThunkFrame
{
get
{
return new WaitOrTimerCallback(UnhandledExceptionFrame);
}
}
[Fx.Tag.SecurityNote(Critical="Calls PrepareConstrainedRegions which has a LinkDemand",
Safe="Guaranteed not to call into PT user code from the finally.")]
[SecuritySafeCritical]
void UnhandledExceptionFrame(object state, bool timedOut)
{
RuntimeHelpers.PrepareConstrainedRegions();
try
{
Callback(state, timedOut);
}
catch (Exception exception)
{
if (!Fx.HandleAtThreadBase(exception))
{
throw;
}
}
}
}
sealed class SendOrPostThunk : Thunk
{
public SendOrPostThunk(SendOrPostCallback callback) : base(callback)
{
}
public SendOrPostCallback ThunkFrame
{
get
{
return new SendOrPostCallback(UnhandledExceptionFrame);
}
}
[Fx.Tag.SecurityNote(Critical="Calls PrepareConstrainedRegions which has a LinkDemand",
Safe="Guaranteed not to call into PT user code from the finally.")]
[SecuritySafeCritical]
void UnhandledExceptionFrame(object state)
{
RuntimeHelpers.PrepareConstrainedRegions();
try
{
Callback(state);
}
catch (Exception exception)
{
if (!Fx.HandleAtThreadBase(exception))
{
throw;
}
}
}
}
// This can't derive from Thunk since T would be unsafe.
[Fx.Tag.SecurityNote(Critical="unsafe object")]
[SecurityCritical]
unsafe sealed class IOCompletionThunk
{
[Fx.Tag.SecurityNote(Critical = "Make these safe to use in SecurityCritical contexts.")]
IOCompletionCallback callback;
[Fx.Tag.SecurityNote(Critical = "Accesses critical field.", Safe = "Data provided by caller.")]
public IOCompletionThunk(IOCompletionCallback callback)
{
this.callback = callback;
}
public IOCompletionCallback ThunkFrame
{
[Fx.Tag.SecurityNote(Safe="returns a delegate around the safe method UnhandledExceptionFrame")]
get
{
return new IOCompletionCallback(UnhandledExceptionFrame);
}
}
[Fx.Tag.SecurityNote(Critical = "Accesses critical field, calls PrepareConstrainedRegions which has a LinkDemand",
Safe = "Delegates can be invoked, guaranteed not to call into PT user code from the finally.")]
void UnhandledExceptionFrame(uint error, uint bytesRead, NativeOverlapped *nativeOverlapped)
{
RuntimeHelpers.PrepareConstrainedRegions();
try
{
this.callback(error, bytesRead, nativeOverlapped);
}
catch (Exception exception)
{
if (!Fx.HandleAtThreadBase(exception))
{
throw;
}
}
}
}
[Serializable]
class InternalException : SystemException
{
public InternalException(string description)
: base(SRCore.ShipAssertExceptionMessage(description))
{
}
protected InternalException(SerializationInfo info, StreamingContext context)
: base(info, context)
{
}
}
[Serializable]
class FatalInternalException : InternalException
{
public FatalInternalException(string description)
: base(description)
{
}
protected FatalInternalException(SerializationInfo info, StreamingContext context)
: base(info, context)
{
}
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- CompositionAdorner.cs
- InputMethodStateChangeEventArgs.cs
- _IPv6Address.cs
- Types.cs
- ChameleonKey.cs
- DetailsViewUpdatedEventArgs.cs
- MailWriter.cs
- CompositeScriptReference.cs
- WithParamAction.cs
- WorkflowServiceInstance.cs
- InputBinder.cs
- CompilerWrapper.cs
- CodeValidator.cs
- ButtonBaseAdapter.cs
- RawStylusInputCustomData.cs
- Sentence.cs
- SmtpReplyReaderFactory.cs
- SafeNativeMethods.cs
- TdsParserStaticMethods.cs
- DynamicDocumentPaginator.cs
- SignatureConfirmations.cs
- GlyphElement.cs
- Base64Encoder.cs
- EvidenceBase.cs
- InputProcessorProfiles.cs
- ProjectionCamera.cs
- MetafileHeader.cs
- ScriptingSectionGroup.cs
- XpsSerializerWriter.cs
- InstanceKeyCompleteException.cs
- DeobfuscatingStream.cs
- FileFormatException.cs
- FixedSOMLineRanges.cs
- WindowsListViewScroll.cs
- FormParameter.cs
- ControlCollection.cs
- ComplexType.cs
- HttpModuleActionCollection.cs
- ConfigurationManagerInternalFactory.cs
- XsltFunctions.cs
- InvalidDataContractException.cs
- DBSqlParserColumnCollection.cs
- Timer.cs
- DetailsView.cs
- StoryFragments.cs
- MultiByteCodec.cs
- XmlQueryContext.cs
- BigIntegerStorage.cs
- XmlDataSourceNodeDescriptor.cs
- HostingEnvironmentException.cs
- BlockUIContainer.cs
- ToolStripItem.cs
- WeakReadOnlyCollection.cs
- SingleAnimationUsingKeyFrames.cs
- TextSpanModifier.cs
- ScrollEvent.cs
- XmlComplianceUtil.cs
- InputMethod.cs
- WebScriptServiceHostFactory.cs
- dbdatarecord.cs
- LogSwitch.cs
- SamlAuthorizationDecisionClaimResource.cs
- ObjectConverter.cs
- StringComparer.cs
- AttributeUsageAttribute.cs
- StaticFileHandler.cs
- Int16Storage.cs
- PrimitiveCodeDomSerializer.cs
- RelationshipConverter.cs
- DebugHandleTracker.cs
- SiteMapDataSourceView.cs
- PrintingPermissionAttribute.cs
- TransportElement.cs
- GlyphsSerializer.cs
- ListParaClient.cs
- XmlReflectionImporter.cs
- PagesSection.cs
- ResourceWriter.cs
- SimpleTypeResolver.cs
- SamlAction.cs
- WeakReferenceEnumerator.cs
- XmlArrayItemAttribute.cs
- TextElementCollection.cs
- MouseActionValueSerializer.cs
- LineInfo.cs
- KeyValueSerializer.cs
- StreamAsIStream.cs
- HttpsTransportElement.cs
- TCPClient.cs
- SplitterPanel.cs
- XmlSchemaImport.cs
- SqlLiftWhereClauses.cs
- DropShadowBitmapEffect.cs
- WsdlExporter.cs
- UTF32Encoding.cs
- HorizontalAlignConverter.cs
- IntSecurity.cs
- TdsParserSessionPool.cs
- HyperlinkAutomationPeer.cs
- WindowsIPAddress.cs