assertwrapper.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / CompMod / System / Diagnostics / assertwrapper.cs / 1305376 / assertwrapper.cs

                            // ==++== 
//
//   Copyright (c) Microsoft Corporation.  All rights reserved.
//
// ==--== 
using System;
using System.Diagnostics; 
using System.Runtime.InteropServices; 
using Microsoft.Win32;
using System.Security.Permissions; 
using System.Security;
using System.Collections;
using System.Globalization;
using System.Threading; 
#if !SILVERLIGHT
using System.Runtime.Versioning; 
#endif 
using System.Diagnostics.CodeAnalysis;
 
namespace System.Diagnostics {

    internal static class AssertWrapper {
 
#if DEBUG && !FEATURE_PAL && !SILVERLIGHT
        static BooleanSwitch DisableVsAssert = new BooleanSwitch("DisableVsAssert", "Switch to disable usage of VSASSERT for DefaultTraceListener."); 
        static bool vsassertPresent = true; 
        static Hashtable ignoredAsserts = new Hashtable(StringComparer.OrdinalIgnoreCase);
 
        [ResourceExposure(ResourceScope.None)]
        [ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]
        private static void ShowVsAssert(string stackTrace, StackFrame frame, string message, string detailMessage) {
            int[] disable = new int[1]; 
            try {
                string detailMessage2; 
 
                if (detailMessage == null)
                    detailMessage2 = stackTrace; 
                else
                    detailMessage2 = detailMessage + Environment.NewLine + stackTrace;
                string fileName = (frame == null) ? string.Empty : frame.GetFileName();
                if (fileName == null) { 
                    fileName = string.Empty;
                } 
 
                int lineNumber = (frame == null) ? 0 : frame.GetFileLineNumber();
                int returnCode = VsAssert(detailMessage2, message, fileName, lineNumber, disable); 
                if (returnCode != 0) {
                    if (!System.Diagnostics.Debugger.IsAttached) {
                        System.Diagnostics.Debugger.Launch();
                    } 
                    System.Diagnostics.Debugger.Break();
                } 
                if (disable[0] != 0) 
                    ignoredAsserts[MakeAssertKey(fileName, lineNumber)] = null;
            } 
            catch (Exception) {
                vsassertPresent = false;
            }
        } 

        [DllImport(ExternDll.Fxassert, CharSet=System.Runtime.InteropServices.CharSet.Ansi, BestFitMapping=true)] 
        [ResourceExposure(ResourceScope.None)] 
        [SuppressMessage("Microsoft.Globalization","CA2101:SpecifyMarshalingForPInvokeStringArguments", MessageId="0", Justification="[....]: VsAssert isn't making a security decision here and they don't provide Unicode versions, also it is internal to MS")]
        [SuppressMessage("Microsoft.Globalization","CA2101:SpecifyMarshalingForPInvokeStringArguments", MessageId="1", Justification="[....]: VsAssert isn't making a security decision here and they don't provide Unicode versions, also it is internal to MS")] 
        [SuppressMessage("Microsoft.Globalization","CA2101:SpecifyMarshalingForPInvokeStringArguments", MessageId="2", Justification="[....]: VsAssert isn't making a security decision here and they don't provide Unicode versions, also it is internal to MS")]
        public static extern int VsAssert(string message, string assert, string file, int line, [In, Out]int[] pfDisable);

        [ResourceExposure(ResourceScope.None)] 
        public static void ShowAssert(string stackTrace, StackFrame frame, string message, string detailMessage) {
            bool userInteractive = Environment.UserInteractive; 
 
            string fileName = (frame == null) ? string.Empty : frame.GetFileName();
            if (fileName == null) { 
                fileName = string.Empty;
            }

            int lineNumber = (frame == null) ? 0 : frame.GetFileLineNumber(); 

            if (ignoredAsserts.ContainsKey(MakeAssertKey(fileName, lineNumber))) 
                return; 

            if (vsassertPresent && !DisableVsAssert.Enabled && userInteractive) 
                ShowVsAssert(stackTrace, frame, message, detailMessage);

            // the following is not in an 'else' because vsassertPresent might
            // have gone from true to false. 

            if (!vsassertPresent || DisableVsAssert.Enabled || !userInteractive) 
                ShowMessageBoxAssert(stackTrace, message, detailMessage); 
        }
 
        private static string MakeAssertKey(string fileName, int lineNumber) {
            return fileName + ":" + lineNumber.ToString(CultureInfo.InvariantCulture);
        }
 
#else // DEBUG && !FEATURE_PAL && !SILVERLIGHT
 
        public static void ShowAssert(string stackTrace, StackFrame frame, string message, string detailMessage) { 
#if SILVERLIGHT && FEATURE_PAL
                ShowCFUserNotificationDisplayAlertAssert(stackTrace, message, detailMessage); 
#else // !(SILVERLIGHT && FEATURE_PAL)
                ShowMessageBoxAssert(stackTrace, message, detailMessage);
#endif
        } 

#endif // DEBUG && !FEATURE_PAL && !SILVERLIGHT 
 
#if !SILVERLIGHT
        [ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)] 
#endif
        [SecuritySafeCritical]
        private static void ShowMessageBoxAssert(string stackTrace, string message, string detailMessage) {
            string fullMessage = message + Environment.NewLine + detailMessage + Environment.NewLine + stackTrace; 

#if !FEATURE_PAL 
            fullMessage = TruncateMessageToFitScreen(fullMessage); 
#endif // !FEATURE_PAL
 
#if SILVERLIGHT
            int flags = 0x00000001 /*OkCancel*/ | 0x00000010 /*IconHand*/ |
                        0x00040000 /* TopMost */;
#else 
            int flags = 0x00000002 /*AbortRetryIgnore*/ | 0x00000200 /*DefaultButton3*/ | 0x00000010 /*IconHand*/ |
                        0x00040000 /* TopMost */; 
#endif 

#if !SILVERLIGHT 
            if (!Environment.UserInteractive)
                flags = flags | 0x00200000 /*ServiceNotification */;
#endif
 
            if (IsRTLResources)
                flags = flags | SafeNativeMethods.MB_RIGHT | SafeNativeMethods.MB_RTLREADING; 
#if !SILVERLIGHT 
            int rval = SafeNativeMethods.MessageBox(IntPtr.Zero, fullMessage, SR.GetString(SR.DebugAssertTitle), flags);
#else 
            // Run the message box on its own thread.
            int rval = new MessageBoxPopup(fullMessage, SR.GetString(SR.DebugAssertTitle), flags).ShowMessageBox();
#endif
 
            switch (rval) {
#if !SILVERLIGHT 
                case 3: // abort 
                    System.Environment.Exit(1);
                    break; 
                case 4: // retry
#else
                case 2: // cancel
#endif 
                    if (!System.Diagnostics.Debugger.IsAttached) {
                        System.Diagnostics.Debugger.Launch(); 
                    } 
                    System.Diagnostics.Debugger.Break();
                    break; 
            }
        }

 
        private static bool IsRTLResources {
            get { 
                return SR.GetString(SR.RTL) != "RTL_False"; 
            }
        } 

#if SILVERLIGHT && FEATURE_PAL
        [SecuritySafeCritical]
        private static void ShowCFUserNotificationDisplayAlertAssert(string stackTrace, string message, string detailMessage) 
        {
            IntPtr cfsContinueText, cfsFullMessage, cfsTitle; 
 
            string fullMessage = message + Environment.NewLine + detailMessage + Environment.NewLine + stackTrace;
 
            cfsFullMessage = SafeNativeMethods.CFStringCreateWithCharacters(IntPtr.Zero, fullMessage, fullMessage.Length);
            cfsContinueText = SafeNativeMethods.CFStringCreateWithCharacters(IntPtr.Zero, SR.GetString(SR.ContinueButtonText), SR.GetString(SR.ContinueButtonText).Length);
            cfsTitle = SafeNativeMethods.CFStringCreateWithCharacters(IntPtr.Zero, SR.GetString(SR.DebugAssertTitleShort), SR.GetString(SR.DebugAssertTitleShort).Length);
 
            uint rval = 0;
 
            SafeNativeMethods.CFUserNotificationDisplayAlert(0, 0, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, cfsTitle, cfsFullMessage, cfsContinueText, IntPtr.Zero, IntPtr.Zero, ref rval); 

            SafeNativeMethods.CFRelease(cfsFullMessage); 
            SafeNativeMethods.CFRelease(cfsContinueText);
            SafeNativeMethods.CFRelease(cfsTitle);

            // We don't care about the return value of CFUserNotificationDisplayAlert. 
        }
#endif 
 

#if !FEATURE_PAL 
        // Since MessageBox will grow taller than the screen if there are too many lines do
        // a rough calculation to make it fit.
#if !SILVERLIGHT
        [ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)] 
#endif
        [SecuritySafeCritical] 
        [SuppressMessage("Microsoft.Usage", "CA1806:DoNotIgnoreMethodResults", MessageId = "Microsoft.Win32.UnsafeNativeMethods.ReleaseDC(System.IntPtr,System.IntPtr)", Justification = "[....]: If the DC is not released there's not much we can do.")] 
        private static string TruncateMessageToFitScreen(string message) {
            const int MaxCharsPerLine = 80; 

            IntPtr hFont = SafeNativeMethods.GetStockObject(NativeMethods.DEFAULT_GUI_FONT);
            IntPtr hdc = UnsafeNativeMethods.GetDC(IntPtr.Zero);
            NativeMethods.TEXTMETRIC tm = new NativeMethods.TEXTMETRIC(); 
            hFont = UnsafeNativeMethods.SelectObject(hdc, hFont);
            SafeNativeMethods.GetTextMetrics(hdc, tm); 
            UnsafeNativeMethods.SelectObject(hdc, hFont); 
            UnsafeNativeMethods.ReleaseDC(IntPtr.Zero, hdc);
            hdc = IntPtr.Zero; 
            int cy = UnsafeNativeMethods.GetSystemMetrics(NativeMethods.SM_CYSCREEN);
            int maxLines = cy / tm.tmHeight - 15;

            int lineCount = 0; 
            int lineCharCount = 0;
            int i = 0; 
            while (lineCount < maxLines && i < message.Length - 1) { 
                char ch = message[i];
                lineCharCount++; 
                if (ch == '\n' || ch == '\r' || lineCharCount > MaxCharsPerLine) {
                    lineCount++;
                    lineCharCount = 0;
                } 

                // treat \r\n or \n\r as a single line break 
                if (ch == '\r' && message[i + 1] == '\n') 
                    i+=2;
                else if (ch == '\n' && message[i + 1] == '\r') 
                    i+=2;
                else
                    i++;
            } 
            if (i < message.Length - 1)
                message = SR.GetString(SR.DebugMessageTruncated, message.Substring(0, i)); 
            return message; 
        }
#endif // !FEATURE_PAL 
    }

#if SILVERLIGHT
    internal class MessageBoxPopup { 
        public int ReturnValue { get; set; }
        private AutoResetEvent m_Event; 
        private string m_Body; 
        private string m_Title;
        private int m_Flags; 

        public MessageBoxPopup(string body, string title, int flags) {
            m_Event = new AutoResetEvent(false);
            m_Body = body; 
            m_Title = title;
            m_Flags = flags; 
        } 

        public int ShowMessageBox() { 

            Thread t = new Thread(DoPopup);
            t.Start();
            m_Event.WaitOne(); 
            return ReturnValue;
        } 
 
        [SecuritySafeCritical]
        public void DoPopup() { 
            ReturnValue = SafeNativeMethods.MessageBox(IntPtr.Zero, m_Body, m_Title, m_Flags);
            m_Event.Set();
        }
    } 
#endif
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
                        

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK