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

1098 lines
39 KiB
C#

//------------------------------------------------------------------------------
// <copyright file="Debug.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//------------------------------------------------------------------------------
namespace System.Web.Util {
using Microsoft.Win32;
using Microsoft.Win32.SafeHandles;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Globalization;
using System.Reflection;
using System.Runtime.ConstrainedExecution;
using System.Runtime.InteropServices;
using System.Security;
using System.Security.Permissions;
using System.Threading;
using System.Runtime.Versioning;
internal static class Debug {
internal const string TAG_INTERNAL = "Internal";
internal const string TAG_EXTERNAL = "External";
internal const string TAG_ALL = "*";
internal const string DATE_FORMAT = @"yyyy/MM/dd HH:mm:ss.ffff";
internal const string TIME_FORMAT = @"HH:mm:ss:ffff";
// Some of these APIs must be always available, not #ifdefed away.
[SuppressUnmanagedCodeSecurity]
private static partial class NativeMethods {
[DllImport("kernel32.dll")]
internal extern static bool IsDebuggerPresent();
}
#if DBG
private static partial class NativeMethods {
[DllImport("kernel32.dll")]
internal extern static void DebugBreak();
[DllImport("kernel32.dll")]
internal extern static int GetCurrentProcessId();
[DllImport("kernel32.dll")]
internal extern static int GetCurrentThreadId();
[DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
internal extern static IntPtr GetCurrentProcess();
[DllImport("kernel32.dll", SetLastError=true)]
internal extern static bool TerminateProcess(HandleRef processHandle, int exitCode);
[DllImport("kernel32.dll", CharSet=CharSet.Auto, BestFitMapping=false)]
internal extern static void OutputDebugString(string message);
internal const int PM_NOREMOVE = 0x0000;
internal const int PM_REMOVE = 0x0001;
[StructLayout(LayoutKind.Sequential)]
internal struct MSG {
internal IntPtr hwnd;
internal int message;
internal IntPtr wParam;
internal IntPtr lParam;
internal int time;
internal int pt_x;
internal int pt_y;
}
[DllImport("user32.dll", CharSet=System.Runtime.InteropServices.CharSet.Auto)]
internal extern static bool PeekMessage([In, Out] ref MSG msg, HandleRef hwnd, int msgMin, int msgMax, int remove);
internal const int
MB_OK = 0x00000000,
MB_OKCANCEL = 0x00000001,
MB_ABORTRETRYIGNORE = 0x00000002,
MB_YESNOCANCEL = 0x00000003,
MB_YESNO = 0x00000004,
MB_RETRYCANCEL = 0x00000005,
MB_ICONHAND = 0x00000010,
MB_ICONQUESTION = 0x00000020,
MB_ICONEXCLAMATION = 0x00000030,
MB_ICONASTERISK = 0x00000040,
MB_USERICON = 0x00000080,
MB_ICONWARNING = 0x00000030,
MB_ICONERROR = 0x00000010,
MB_ICONINFORMATION = 0x00000040,
MB_DEFBUTTON1 = 0x00000000,
MB_DEFBUTTON2 = 0x00000100,
MB_DEFBUTTON3 = 0x00000200,
MB_DEFBUTTON4 = 0x00000300,
MB_APPLMODAL = 0x00000000,
MB_SYSTEMMODAL = 0x00001000,
MB_TASKMODAL = 0x00002000,
MB_HELP = 0x00004000,
MB_NOFOCUS = 0x00008000,
MB_SETFOREGROUND = 0x00010000,
MB_DEFAULT_DESKTOP_ONLY = 0x00020000,
MB_TOPMOST = 0x00040000,
MB_RIGHT = 0x00080000,
MB_RTLREADING = 0x00100000,
MB_SERVICE_NOTIFICATION = 0x00200000,
MB_SERVICE_NOTIFICATION_NT3X = 0x00040000,
MB_TYPEMASK = 0x0000000F,
MB_ICONMASK = 0x000000F0,
MB_DEFMASK = 0x00000F00,
MB_MODEMASK = 0x00003000,
MB_MISCMASK = 0x0000C000;
internal const int
IDOK = 1,
IDCANCEL = 2,
IDABORT = 3,
IDRETRY = 4,
IDIGNORE = 5,
IDYES = 6,
IDNO = 7,
IDCLOSE = 8,
IDHELP = 9;
[DllImport("user32.dll", CharSet=CharSet.Auto, BestFitMapping=false)]
internal extern static int MessageBox(HandleRef hWnd, string text, string caption, int type);
internal static readonly IntPtr HKEY_LOCAL_MACHINE = unchecked((IntPtr)(int)0x80000002);
internal const int READ_CONTROL = 0x00020000;
internal const int STANDARD_RIGHTS_READ = READ_CONTROL;
internal const int SYNCHRONIZE = 0x00100000;
internal const int KEY_QUERY_VALUE = 0x0001;
internal const int KEY_ENUMERATE_SUB_KEYS = 0x0008;
internal const int KEY_NOTIFY = 0x0010;
internal const int KEY_READ = ((STANDARD_RIGHTS_READ |
KEY_QUERY_VALUE |
KEY_ENUMERATE_SUB_KEYS |
KEY_NOTIFY)
&
(~SYNCHRONIZE));
internal const int REG_NOTIFY_CHANGE_NAME = 1;
internal const int REG_NOTIFY_CHANGE_LAST_SET = 4;
[DllImport("advapi32.dll", CharSet=CharSet.Auto, BestFitMapping=false, SetLastError=true)]
internal extern static int RegOpenKeyEx(IntPtr hKey, string lpSubKey, int ulOptions, int samDesired, out SafeRegistryHandle hkResult);
[DllImport("advapi32.dll", ExactSpelling=true, SetLastError=true)]
internal extern static int RegNotifyChangeKeyValue(SafeRegistryHandle hKey, bool watchSubTree, uint notifyFilter, SafeWaitHandle regEvent, bool async);
}
private class SafeRegistryHandle : SafeHandleZeroOrMinusOneIsInvalid {
// Note: Officially -1 is the recommended invalid handle value for
// registry keys, but we'll also get back 0 as an invalid handle from
// RegOpenKeyEx.
[SecurityPermission(SecurityAction.LinkDemand, UnmanagedCode=true)]
[ResourceExposure(ResourceScope.Machine)]
internal SafeRegistryHandle() : base(true) {}
[DllImport("advapi32.dll"),
SuppressUnmanagedCodeSecurity,
ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
private static extern int RegCloseKey(IntPtr hKey);
override protected bool ReleaseHandle()
{
// Returns a Win32 error code, 0 for success
int r = RegCloseKey(handle);
return r == 0;
}
}
private enum TagValue {
Disabled = 0,
Enabled = 1,
Break = 2,
Min = Disabled,
Max = Break,
}
private const string TAG_ASSERT = "Assert";
private const string TAG_ASSERT_BREAK = "AssertBreak";
private const string TAG_DEBUG_VERBOSE = "DebugVerbose";
private const string TAG_DEBUG_MONITOR = "DebugMonitor";
private const string TAG_DEBUG_PREFIX = "DebugPrefix";
private const string TAG_DEBUG_THREAD_PREFIX = "DebugThreadPrefix";
private const string PRODUCT = "Microsoft .NET Framework";
private const string COMPONENT = "System.Web";
private static string s_regKeyName = @"Software\Microsoft\ASP.NET\Debug";
private static string s_listenKeyName = @"Software\Microsoft";
private static bool s_assert;
private static bool s_assertBreak;
private static bool s_includePrefix;
private static bool s_includeThreadPrefix;
private static bool s_monitor;
private static object s_lock;
private static volatile bool s_inited;
private static ReadOnlyCollection<Tag> s_tagDefaults;
private static List<Tag> s_tags;
private static AutoResetEvent s_notifyEvent;
private static RegisteredWaitHandle s_waitHandle;
private static SafeRegistryHandle s_regHandle;
private static bool s_stopMonitoring;
private static Hashtable s_tableAlwaysValidate;
private static Type[] s_DumpArgs;
private static Type[] s_ValidateArgs;
private class Tag {
string _name;
TagValue _value;
int _prefixLength;
internal Tag(string name, TagValue value) {
_name = name;
_value = value;
if (_name[_name.Length - 1] == '*') {
_prefixLength = _name.Length - 1;
}
else {
_prefixLength = -1;
}
}
internal string Name {
get {return _name;}
}
internal TagValue Value {
get {return _value;}
}
internal int PrefixLength {
get {return _prefixLength;}
}
}
static Debug() {
s_lock = new object();
}
private static void EnsureInit() {
bool continueInit = false;
if (!s_inited) {
lock (s_lock) {
if (!s_inited) {
s_tableAlwaysValidate = new Hashtable();
s_DumpArgs = new Type[1] {typeof(string)};
s_ValidateArgs = new Type[0];
List<Tag> tagDefaults = new List<Tag>();
tagDefaults.Add(new Tag(TAG_ALL, TagValue.Disabled));
tagDefaults.Add(new Tag(TAG_INTERNAL, TagValue.Enabled));
tagDefaults.Add(new Tag(TAG_EXTERNAL, TagValue.Enabled));
tagDefaults.Add(new Tag(TAG_ASSERT, TagValue.Break));
tagDefaults.Add(new Tag(TAG_ASSERT_BREAK, TagValue.Disabled));
tagDefaults.Add(new Tag(TAG_DEBUG_VERBOSE, TagValue.Enabled));
tagDefaults.Add(new Tag(TAG_DEBUG_MONITOR, TagValue.Enabled));
tagDefaults.Add(new Tag(TAG_DEBUG_PREFIX, TagValue.Enabled));
tagDefaults.Add(new Tag(TAG_DEBUG_THREAD_PREFIX, TagValue.Enabled));
s_tagDefaults = tagDefaults.AsReadOnly();
s_tags = new List<Tag>(s_tagDefaults);
GetBuiltinTagValues();
continueInit = true;
s_inited = true;
}
}
}
// Work to do outside the init lock.
if (continueInit) {
ReadTagsFromRegistry();
Trace(TAG_DEBUG_VERBOSE, "Debugging package initialized");
// Need to read tags before starting to monitor in order to get TAG_DEBUG_MONITOR
StartRegistryMonitor();
}
}
private static bool StringEqualsIgnoreCase(string s1, string s2) {
return StringComparer.OrdinalIgnoreCase.Equals(s1, s2);
}
[RegistryPermission(SecurityAction.Assert, Unrestricted=true)]
private static void WriteTagsToRegistry() {
try {
using (RegistryKey key = Registry.LocalMachine.CreateSubKey(s_regKeyName)) {
List<Tag> tags = s_tags;
foreach (Tag tag in tags) {
key.SetValue(tag.Name, tag.Value, RegistryValueKind.DWord);
}
}
}
catch {
}
}
private static void GetBuiltinTagValues() {
// Use GetTagValue instead of IsTagEnabled because it does not call EnsureInit
// and potentially recurse.
s_assert = (GetTagValue(TAG_ASSERT) != TagValue.Disabled);
s_assertBreak = (GetTagValue(TAG_ASSERT_BREAK) != TagValue.Disabled);
s_includePrefix = (GetTagValue(TAG_DEBUG_PREFIX) != TagValue.Disabled);
s_includeThreadPrefix = (GetTagValue(TAG_DEBUG_THREAD_PREFIX) != TagValue.Disabled);
s_monitor = (GetTagValue(TAG_DEBUG_MONITOR) != TagValue.Disabled);
}
[RegistryPermission(SecurityAction.Assert, Unrestricted=true)]
private static void ReadTagsFromRegistry() {
lock (s_lock) {
try {
List<Tag> tags = new List<Tag>(s_tagDefaults);
string[] names = null;
bool writeTags = false;
using (RegistryKey key = Registry.LocalMachine.OpenSubKey(s_regKeyName, false)) {
if (key != null) {
names = key.GetValueNames();
foreach (string name in names) {
TagValue value = TagValue.Disabled;
try {
TagValue keyvalue = (TagValue) key.GetValue(name);
if (TagValue.Min <= keyvalue && keyvalue <= TagValue.Max) {
value = keyvalue;
}
else {
writeTags = true;
}
}
catch {
writeTags = true;
}
// Add tag to list, making sure it is unique.
Tag tag = new Tag(name, (TagValue) value);
bool found = false;
for (int i = 0; i < s_tagDefaults.Count; i++) {
if (StringEqualsIgnoreCase(name, tags[i].Name)) {
found = true;
tags[i] = tag;
break;
}
}
if (!found) {
tags.Add(tag);
}
}
}
}
s_tags = tags;
GetBuiltinTagValues();
// Write tags out if there was an invalid value or
// not all default tags are present.
if (writeTags || (names != null && names.Length < tags.Count)) {
WriteTagsToRegistry();
}
}
catch {
s_tags = new List<Tag>(s_tagDefaults);
}
}
}
private static void StartRegistryMonitor() {
if (!s_monitor) {
Trace(TAG_DEBUG_VERBOSE, "WARNING: Registry monitoring disabled, changes during process execution will not be recognized.");
return;
}
Trace(TAG_DEBUG_VERBOSE, "Monitoring registry key " + s_listenKeyName + " for changes.");
// Event used to notify of changes.
s_notifyEvent = new AutoResetEvent(false);
// Register a wait on the event.
s_waitHandle = ThreadPool.RegisterWaitForSingleObject(s_notifyEvent, OnRegChangeKeyValue, null, -1, false);
// Monitor the registry.
MonitorRegistryForOneChange();
}
private static void StopRegistryMonitor() {
// Cleanup allocated handles
s_stopMonitoring = true;
if (s_regHandle != null) {
s_regHandle.Close();
s_regHandle = null;
}
if (s_waitHandle != null) {
s_waitHandle.Unregister(s_notifyEvent);
s_waitHandle = null;
}
if (s_notifyEvent != null) {
s_notifyEvent.Close();
s_notifyEvent = null;
}
Trace(TAG_DEBUG_VERBOSE, "Registry monitoring stopped.");
}
public static void OnRegChangeKeyValue(object state, bool timedOut) {
if (!s_stopMonitoring) {
if (timedOut) {
StopRegistryMonitor();
}
else {
// Monitor again
MonitorRegistryForOneChange();
// Once we're monitoring, read the changes to the registry.
// We have to do this after we start monitoring in order
// to catch all changes to the registry.
ReadTagsFromRegistry();
}
}
}
private static void MonitorRegistryForOneChange() {
// Close the open reg handle
if (s_regHandle != null) {
s_regHandle.Close();
s_regHandle = null;
}
// Open the reg key
int result = NativeMethods.RegOpenKeyEx(NativeMethods.HKEY_LOCAL_MACHINE, s_listenKeyName, 0, NativeMethods.KEY_READ, out s_regHandle);
if (result != 0) {
StopRegistryMonitor();
return;
}
// Listen for changes.
result = NativeMethods.RegNotifyChangeKeyValue(
s_regHandle,
true,
NativeMethods.REG_NOTIFY_CHANGE_NAME | NativeMethods.REG_NOTIFY_CHANGE_LAST_SET,
s_notifyEvent.SafeWaitHandle,
true);
if (result != 0) {
StopRegistryMonitor();
}
}
private static Tag FindMatchingTag(string name, bool exact) {
List<Tag> tags = s_tags;
// Look for exact match first
foreach (Tag tag in tags) {
if (StringEqualsIgnoreCase(name, tag.Name)) {
return tag;
}
}
if (exact) {
return null;
}
Tag longestTag = null;
int longestPrefix = -1;
foreach (Tag tag in tags) {
if ( tag.PrefixLength > longestPrefix &&
0 == string.Compare(name, 0, tag.Name, 0, tag.PrefixLength, StringComparison.OrdinalIgnoreCase)) {
longestTag = tag;
longestPrefix = tag.PrefixLength;
}
}
return longestTag;
}
private static TagValue GetTagValue(string name) {
Tag tag = FindMatchingTag(name, false);
if (tag != null) {
return tag.Value;
}
else {
return TagValue.Disabled;
}
}
[PermissionSet(SecurityAction.Assert, Unrestricted = true)]
private static bool TraceBreak(string tagName, string message, Exception e, bool includePrefix) {
EnsureInit();
TagValue tagValue = GetTagValue(tagName);
if (tagValue == TagValue.Disabled) {
return false;
}
bool isAssert = object.ReferenceEquals(tagName, TAG_ASSERT);
if (isAssert) {
tagName = "";
}
string exceptionMessage = null;
if (e != null) {
string httpCode = null;
string errorCode = null;
if (e is HttpException) {
httpCode = " _httpCode=" + ((HttpException)e).GetHttpCode().ToString(CultureInfo.InvariantCulture) + " ";
}
if (e is ExternalException) {
// note that HttpExceptions are ExternalExceptions
errorCode = "_hr=0x" + ((ExternalException)e).ErrorCode.ToString("x", CultureInfo.InvariantCulture);
}
// Use e.ToString() in order to get inner exception
if (errorCode != null) {
exceptionMessage = "Exception " + e.ToString() + "\n" + httpCode + errorCode;
}
else {
exceptionMessage = "Exception " + e.ToString();
}
}
if (string.IsNullOrEmpty(message) & exceptionMessage != null) {
message = exceptionMessage;
exceptionMessage = null;
}
string traceFormat;
int idThread = 0;
int idProcess = 0;
if (!includePrefix || !s_includePrefix) {
traceFormat = "{4}\n{5}";
}
else {
if (s_includeThreadPrefix) {
idThread = NativeMethods.GetCurrentThreadId();
idProcess = NativeMethods.GetCurrentProcessId();
traceFormat = "[0x{0:x}.{1:x} {2} {3}] {4}\n{5}";
}
else {
traceFormat = "[{2} {3}] {4}\n{5}";
}
}
string suffix = "";
if (exceptionMessage != null) {
suffix += exceptionMessage + "\n";
}
bool doBreak = (tagValue == TagValue.Break);
if (doBreak && !isAssert) {
suffix += "Breaking into debugger...\n";
}
string traceMessage = string.Format(CultureInfo.InvariantCulture, traceFormat, idProcess, idThread, COMPONENT, tagName, message, suffix);
NativeMethods.OutputDebugString(traceMessage);
return doBreak;
}
private class MBResult {
internal int Result;
}
[ResourceExposure(ResourceScope.None)]
static bool DoAssert(string message) {
if (!s_assert) {
return false;
}
// Skip 2 frames - one for this function, one for
// the public Assert function that called this function.
System.Diagnostics.StackFrame frame = new System.Diagnostics.StackFrame(2, true);
System.Diagnostics.StackTrace trace = new System.Diagnostics.StackTrace(2, true);
string fileName = frame.GetFileName();
int lineNumber = frame.GetFileLineNumber();
string traceFormat;
if (!string.IsNullOrEmpty(fileName)) {
traceFormat = "ASSERTION FAILED: {0}\nFile: {1}:{2}\nStack trace:\n{3}";
}
else {
traceFormat = "ASSERTION FAILED: {0}\nStack trace:\n{3}";
}
string traceMessage = string.Format(CultureInfo.InvariantCulture, traceFormat, message, fileName, lineNumber, trace.ToString());
if (!TraceBreak(TAG_ASSERT, traceMessage, null, true)) {
// If the value of "Assert" is not TagValue.Break, then don't even ask user.
return false;
}
if (s_assertBreak) {
// If "AssertBreak" is enabled, then always break.
return true;
}
string dialogFormat;
if (!string.IsNullOrEmpty(fileName)) {
dialogFormat =
@"Failed expression: {0}
File: {1}:{2}
Component: {3}
PID={4} TID={5}
Stack trace:
{6}
A=Exit process R=Debug I=Continue";
}
else {
dialogFormat =
@"Failed expression: {0}
(no file information available)
Component: {3}
PID={4} TID={5}
Stack trace:
{6}
A=Exit process R=Debug I=Continue";
}
string dialogMessage = string.Format(
CultureInfo.InvariantCulture,
dialogFormat,
message,
fileName, lineNumber,
COMPONENT,
NativeMethods.GetCurrentProcessId(), NativeMethods.GetCurrentThreadId(),
trace.ToString());
MBResult mbResult = new MBResult();
Thread thread = new Thread(
delegate() {
for (int i = 0; i < 100; i++) {
NativeMethods.MSG msg = new NativeMethods.MSG();
NativeMethods.PeekMessage(ref msg, new HandleRef(mbResult, IntPtr.Zero), 0, 0, NativeMethods.PM_REMOVE);
}
mbResult.Result = NativeMethods.MessageBox(new HandleRef(mbResult, IntPtr.Zero), dialogMessage, PRODUCT + " Assertion",
NativeMethods.MB_SERVICE_NOTIFICATION |
NativeMethods.MB_TOPMOST |
NativeMethods.MB_ABORTRETRYIGNORE |
NativeMethods.MB_ICONEXCLAMATION);
}
);
thread.Start();
thread.Join();
if (mbResult.Result == NativeMethods.IDABORT) {
IntPtr currentProcess = NativeMethods.GetCurrentProcess();
NativeMethods.TerminateProcess(new HandleRef(mbResult, currentProcess), 1);
}
return mbResult.Result == NativeMethods.IDRETRY;
}
#endif
//
// Sends the message to the debugger if the tag is enabled.
// Also breaks into the debugger the value of the tag is 2 (TagValue.Break).
//
[System.Diagnostics.Conditional("DBG")]
internal static void Trace(string tagName, string message) {
#if DBG
if (TraceBreak(tagName, message, null, true)) {
Break();
}
#endif
}
//
// Sends the message to the debugger if the tag is enabled.
// Also breaks into the debugger the value of the tag is 2 (TagValue.Break).
//
[System.Diagnostics.Conditional("DBG")]
internal static void Trace(string tagName, string message, bool includePrefix) {
#if DBG
if (TraceBreak(tagName, message, null, includePrefix)) {
Break();
}
#endif
}
//
// Sends the message to the debugger if the tag is enabled.
// Also breaks into the debugger the value of the tag is 2 (TagValue.Break).
//
[System.Diagnostics.Conditional("DBG")]
internal static void Trace(string tagName, string message, Exception e) {
#if DBG
if (TraceBreak(tagName, message, e, true)) {
Break();
}
#endif
}
//
// Sends the message to the debugger if the tag is enabled.
// Also breaks into the debugger the value of the tag is 2 (TagValue.Break).
//
[System.Diagnostics.Conditional("DBG")]
internal static void Trace(string tagName, Exception e) {
#if DBG
if (TraceBreak(tagName, null, e, true)) {
Break();
}
#endif
}
//
// Sends the message to the debugger if the tag is enabled.
// Also breaks into the debugger the value of the tag is 2 (TagValue.Break).
//
[System.Diagnostics.Conditional("DBG")]
internal static void Trace(string tagName, string message, Exception e, bool includePrefix) {
#if DBG
if (TraceBreak(tagName, message, e, includePrefix)) {
Break();
}
#endif
}
#if DBG
#endif
[System.Diagnostics.Conditional("DBG")]
public static void TraceException(String tagName, Exception e) {
#if DBG
if (TraceBreak(tagName, null, e, true)) {
Break();
}
#endif
}
//
// If the assertion is false and the 'Assert' tag is enabled:
// * Send a message to the debugger.
// * If the 'AssertBreak' tag is enabled, immediately break into the debugger
// * Else display a dialog box asking the user to Abort, Retry (break), or Ignore
//
[System.Diagnostics.Conditional("DBG")]
internal static void Assert(bool assertion, string message) {
#if DBG
EnsureInit();
if (assertion == false) {
if (DoAssert(message)) {
Break();
}
}
#endif
}
//
// If the assertion is false and the 'Assert' tag is enabled:
// * Send a message to the debugger.
// * If the 'AssertBreak' tag is enabled, immediately break into the debugger
// * Else display a dialog box asking the user to Abort, Retry (break), or Ignore
//
[System.Diagnostics.Conditional("DBG")]
[ResourceExposure(ResourceScope.None)]
internal static void Assert(bool assertion) {
#if DBG
EnsureInit();
if (assertion == false) {
if (DoAssert(null)) {
Break();
}
}
#endif
}
//
// Like Assert, but the assertion is always considered to be false.
//
[System.Diagnostics.Conditional("DBG")]
[ResourceExposure(ResourceScope.None)]
internal static void Fail(string message) {
#if DBG
Assert(false, message);
#endif
}
//
// Returns true if the tag is enabled, false otherwise.
// Note that the tag needn't be an exact match.
//
[ResourceExposure(ResourceScope.None)]
internal static bool IsTagEnabled(string tagName) {
#if DBG
EnsureInit();
return GetTagValue(tagName) != TagValue.Disabled;
#else
return false;
#endif
}
//
// Returns true if the tag present.
// This function chekcs for an exact match.
//
[ResourceExposure(ResourceScope.None)]
internal static bool IsTagPresent(string tagName) {
#if DBG
EnsureInit();
return FindMatchingTag(tagName, true) != null;
#else
return false;
#endif
}
// Returns a value indicating whether a debugger is attached to the process.
// We don't #ifdef this away since we might need to change behavior based
// on whether one is attached.
internal static bool IsDebuggerPresent() {
return (NativeMethods.IsDebuggerPresent() || System.Diagnostics.Debugger.IsAttached);
}
//
// Breaks into the debugger, or launches one if not yet attached.
//
[System.Diagnostics.Conditional("DBG")]
[ResourceExposure(ResourceScope.None)]
internal static void Break() {
#if DBG
if (NativeMethods.IsDebuggerPresent()) {
NativeMethods.DebugBreak();
}
else if (!System.Diagnostics.Debugger.IsAttached) {
System.Diagnostics.Debugger.Launch();
}
else {
System.Diagnostics.Debugger.Break();
}
#endif
}
//
// Tells the debug system to always validate calls for a
// particular tag. This is useful for temporarily enabling
// validation in stress tests or other situations where you
// may not have control over the debug tags that are enabled
// on a particular machine.
//
[System.Diagnostics.Conditional("DBG")]
internal static void AlwaysValidate(string tagName) {
#if DBG
EnsureInit();
s_tableAlwaysValidate[tagName] = tagName;
#endif
}
//
// Throws an exception if the assertion is not valid.
// Use this function from a DebugValidate method where
// you would otherwise use Assert.
//
[System.Diagnostics.Conditional("DBG")]
internal static void CheckValid(bool assertion, string message) {
#if DBG
if (!assertion) {
throw new Exception(message);
}
#endif
}
//
// Calls DebugValidate on an object if such a method exists.
//
// This method should be used from implementations of DebugValidate
// where it is unknown whether an object has a DebugValidate method.
// For example, the DoubleLink class uses it to validate the
// item of type Object which it points to.
//
// This method should NOT be used when code wants to conditionally
// validate an object and have a failed validation caught in an assert.
// Use Debug.Validate(tagName, obj) for that purpose.
//
[System.Diagnostics.Conditional("DBG")]
[ResourceExposure(ResourceScope.None)]
internal static void Validate(Object obj) {
#if DBG
Type type;
MethodInfo mi;
if (obj != null) {
type = obj.GetType();
mi = type.GetMethod(
"DebugValidate",
BindingFlags.NonPublic | BindingFlags.Instance,
null,
s_ValidateArgs,
null);
if (mi != null) {
object[] tempIndex = null;
mi.Invoke(obj, tempIndex);
}
}
#endif
}
// Ensures that the bounds provided to an array-consuming method are correct.
// Because this method is on the Debug type, it should only be used in debugging
// code and should not be depended on for user input sanitization (since the
// compiler won't emit calls to it.)
[System.Diagnostics.Conditional("DBG")]
internal static void ValidateArrayBounds<T>(T[] array, int offset, int count) {
#if DBG
// these are the same checks as in the ArraySegment<T> ctor
Assert(array != null, "Array cannot be null.");
Assert(offset >= 0, "Offset must be non-negative.");
Assert(count >= 0, "Count must be non-negative.");
Assert(array.Length - offset >= count, "Invalid offset.");
#endif
}
//
// Validates an object is the "Validate" tag is enabled, or when
// the "Validate" tag is not disabled and the given 'tag' is enabled.
// An Assertion is made if the validation fails.
//
[System.Diagnostics.Conditional("DBG")]
[ResourceExposure(ResourceScope.None)]
internal static void Validate(string tagName, Object obj) {
#if DBG
EnsureInit();
if ( obj != null
&& ( IsTagEnabled("Validate")
|| ( !IsTagPresent("Validate")
&& ( s_tableAlwaysValidate[tagName] != null
|| IsTagEnabled(tagName))))) {
try {
Debug.Validate(obj);
}
catch (Exception e) {
Debug.Assert(false, "Validate failed: " + e.InnerException.Message);
}
#pragma warning disable 1058
catch {
Debug.Assert(false, "Validate failed. Non-CLS compliant exception caught.");
}
#pragma warning restore 1058
}
#endif
}
#if DBG
//
// Calls DebugDescription on an object to get its description.
//
// This method should only be used in implementations of DebugDescription
// where it is not known whether a nested objects has an implementation
// of DebugDescription. For example, the double linked list class uses
// GetDescription to get the description of the item it points to.
//
// This method should NOT be used when you want to conditionally
// dump an object. Use Debug.Dump instead.
//
// @param obj The object to call DebugDescription on. May be null.
// @param indent A prefix for each line in the description. This is used
// to allow the nested display of objects within other objects.
// The indent is usually a multiple of four spaces.
//
// @return The description.
//
[ReflectionPermission(SecurityAction.Assert, Unrestricted=true)]
internal static string GetDescription(Object obj, string indent) {
string description;
Type type;
MethodInfo mi;
Object[] parameters;
if (obj == null) {
description = "\n";
}
else {
type = obj.GetType();
mi = type.GetMethod(
"DebugDescription",
BindingFlags.NonPublic | BindingFlags.Instance,
null,
s_DumpArgs,
null);
if (mi == null || mi.ReturnType != typeof(string)) {
description = indent + obj.ToString();
}
else {
parameters = new Object[1] {(Object) indent};
description = (string) mi.Invoke(obj, parameters);
}
}
return description;
}
#endif
//
// Dumps an object to the debugger if the "Dump" tag is enabled,
// or if the "Dump" tag is not present and the 'tag' is enabled.
//
// @param tagName The tag to Dump with.
// @param obj The object to dump.
//
[System.Diagnostics.Conditional("DBG")]
internal static void Dump(string tagName, Object obj) {
#if DBG
EnsureInit();
string description;
string traceTag = null;
bool dumpEnabled, dumpPresent;
if (obj != null) {
dumpEnabled = IsTagEnabled("Dump");
dumpPresent = IsTagPresent("Dump");
if (dumpEnabled || !dumpPresent) {
if (IsTagEnabled(tagName)) {
traceTag = tagName;
}
else if (dumpEnabled) {
traceTag = "Dump";
}
if (traceTag != null) {
description = GetDescription(obj, string.Empty);
Debug.Trace(traceTag, "Dump\n" + description);
}
}
}
#endif
}
#if DBG
static internal string ToStringMaybeNull(object o) {
if (o != null) {
return o.ToString();
}
return "<null>";
}
#endif
static internal string FormatUtcDate(DateTime utcTime) {
#if DBG
DateTime localTime = DateTimeUtil.ConvertToLocalTime(utcTime);
return localTime.ToString(DATE_FORMAT, CultureInfo.InvariantCulture);
#else
return string.Empty;
#endif
}
static internal string FormatLocalDate(DateTime localTime) {
#if DBG
return localTime.ToString(DATE_FORMAT, CultureInfo.InvariantCulture);
#else
return string.Empty;
#endif
}
}
}