Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

1325 lines
45 KiB
C#

//-----------------------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//-----------------------------------------------------------------------------
namespace System.Runtime
{
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
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 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 EtwDiagnosticTrace 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, Trace);
}
return exceptionTrace;
}
}
public static EtwDiagnosticTrace 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 EtwDiagnosticTrace InitializeTracing()
{
EtwDiagnosticTrace trace = new EtwDiagnosticTrace(defaultEventSource, EtwDiagnosticTrace.DefaultEtwProviderId);
if (null != trace.EtwProvider)
{
trace.RefreshState += delegate()
{
Fx.UpdateLevel();
};
}
Fx.UpdateLevel(trace);
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 = InternalSR.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 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 if (exception is AggregateException)
{
// AggregateExceptions have a collection of inner exceptions, which may themselves be other
// wrapping exceptions (including nested AggregateExceptions). Recursively walk this
// hierarchy. The (singular) InnerException is included in the collection.
ReadOnlyCollection<Exception> innerExceptions = ((AggregateException)exception).InnerExceptions;
foreach (Exception innerException in innerExceptions)
{
if (IsFatal(innerException))
{
return true;
}
}
break;
}
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<Type> types = new List<Type>(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 Action<T1> ThunkCallback<T1>(Action<T1> callback)
{
return (new ActionThunk<T1>(callback)).ThunkFrame;
}
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(InternalSR.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(InternalSR.BufferAllocationFailed(size * sizeof(char)), exception));
}
}
[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;
}
static void UpdateLevel(EtwDiagnosticTrace trace)
{
if (trace == null)
{
return;
}
if (TraceCore.ActionItemCallbackInvokedIsEnabled(trace) ||
TraceCore.ActionItemScheduledIsEnabled(trace))
{
trace.SetEnd2EndActivityTracingEnabled(true);
}
}
static void UpdateLevel()
{
UpdateLevel(Fx.Trace);
}
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<T> 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 ActionThunk<T1> : Thunk<Action<T1>>
{
public ActionThunk(Action<T1> callback) : base(callback)
{
}
public Action<T1> ThunkFrame
{
get
{
return new Action<T1>(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(T1 result)
{
RuntimeHelpers.PrepareConstrainedRegions();
try
{
Callback(result);
}
catch (Exception exception)
{
if (!Fx.HandleAtThreadBase(exception))
{
throw;
}
}
}
}
sealed class AsyncThunk : Thunk<AsyncCallback>
{
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<WaitCallback>
{
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<TimerCallback>
{
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<WaitOrTimerCallback>
{
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<SendOrPostCallback>
{
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(InternalSR.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)
{
}
}
}
}