Misc.cs source code in C# .NET

Source code for the .NET framework in C#

                        
Code:

                         / FXUpdate3074 / FXUpdate3074 / 1.1 / untmp / whidbey / QFE / ndp / fx / src / xsp / System / Web / Util / Misc.cs / 7 / Misc.cs
                        

                        
                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
//----------------------------------------------------------------------------- 

namespace System.Web.Util { 
 
    using System.Collections;
    using System.Globalization; 
    using System.Runtime.InteropServices;
    using System.Text;
    using System.Web.Hosting;
    using Microsoft.Win32; 

    internal sealed class Misc { 
 
        const string APPLICATION_ID  = "\r\n\r\nApplication ID: ";
        const string PROCESS_ID      = "\r\n\r\nProcess ID: "; 
        const string EXCEPTION       = "\r\n\r\nException: ";
        const string INNER_EXCEPTION = "\r\n\r\nInnerException: ";
        const string MESSAGE         = "\r\n\r\nMessage: ";
        const string STACK_TRACE     = "\r\n\r\nStackTrace: "; 

        static StringComparer s_caseInsensitiveInvariantKeyComparer; 
 
        internal static StringComparer CaseInsensitiveInvariantKeyComparer {
            get { 
                if (s_caseInsensitiveInvariantKeyComparer == null) {
                    s_caseInsensitiveInvariantKeyComparer = StringComparer.Create(CultureInfo.InvariantCulture, true);
                }
 
                return s_caseInsensitiveInvariantKeyComparer;
            } 
        } 

        internal static void WriteUnhandledExceptionToEventLog(AppDomain appDomain, Exception exception) { 
            if (appDomain == null || exception == null) {
                return;
            }
 
            ProcessImpersonationContext imperContext = null;
            try { 
                imperContext = new ProcessImpersonationContext(); 
                String appId = appDomain.GetData(".appId") as String;
                if (appId == null) { 
                    appId = appDomain.FriendlyName;
                }
                string pid = SafeNativeMethods.GetCurrentProcessId().ToString(CultureInfo.InstalledUICulture);
                string description = SR.Resources.GetString(SR.Unhandled_Exception, CultureInfo.InstalledUICulture); 
                Misc.ReportUnhandledException(exception, new string[5] {description, APPLICATION_ID, appId, PROCESS_ID, pid});
            } 
            catch { 
                // ignore exceptions so that WriteErrorToEventLog never throws
            } 
            finally {
                if (imperContext != null) {
                    imperContext.Undo();
                } 
            }
        } 
 
        internal static void ReportUnhandledException(Exception e, String[] strings) {
            StringBuilder sb = new StringBuilder(4096); 
            for (int i = 0; i < strings.Length; i++) {
                sb.Append(strings[i]);
            }
            for (Exception current = e; current != null; current = current.InnerException) { 
                if (current == e)
                    sb.Append(EXCEPTION); 
                else 
                    sb.Append(INNER_EXCEPTION);
                sb.Append(current.GetType().FullName); 
                sb.Append(MESSAGE);
                sb.Append(current.Message);
                sb.Append(STACK_TRACE);
                sb.Append(current.StackTrace); 
            }
            UnsafeNativeMethods.ReportUnhandledException(sb.ToString()); 
        } 

#if UNUSED_CODE 
        static IKeyComparer s_caseSensitiveInvariantKeyComparer;
        internal static IKeyComparer CaseSensitiveInvariantKeyComparer {
            get {
                if (s_caseSensitiveInvariantKeyComparer == null) { 
                    s_caseSensitiveInvariantKeyComparer = KeyComparer.CreateKeyComparer(CultureInfo.InvariantCulture, false);
                } 
 
                return s_caseSensitiveInvariantKeyComparer;
            } 
        }
#endif

        internal unsafe static void CopyMemory(IntPtr src, int srcOffset, byte[] dest, int destOffset, int size) { 
            //
            System.Runtime.InteropServices.Marshal.Copy(new IntPtr(src.ToInt64()+srcOffset), dest, destOffset, size); 
        } 

        internal unsafe static void CopyMemory(byte[] src, int srcOffset, IntPtr dest, int destOffset, int size) { 
            //
            System.Runtime.InteropServices.Marshal.Copy(src, srcOffset, new IntPtr(dest.ToInt64()+destOffset), size);
        }
 
        internal unsafe static void CopyMemory(IntPtr src, int srcOffset, IntPtr dest, int destOffset, int size) {
            byte *s = ((byte*)src) + srcOffset; 
            byte *d = ((byte*)dest) + destOffset; 
            StringUtil.memcpyimpl(s, d, size);
        } 

        internal static void ThrowIfFailedHr(int hresult) {
            // SUCCEEDED >= 0
            // FAILED < 0 
            if (hresult < 0) {
                Marshal.ThrowExceptionForHR(hresult); 
            } 
        }
 
        internal static IProcessHostSupportFunctions CreateLocalSupportFunctions(IProcessHostSupportFunctions proxyFunctions) {
            IProcessHostSupportFunctions localFunctions = null;

            // get the underlying COM object 
            IntPtr pUnk = Marshal.GetIUnknownForObject(proxyFunctions);
 
            // this object isn't a COM object 
            if (IntPtr.Zero == pUnk) {
                return null; 
            }

            IntPtr ppv = IntPtr.Zero;
            try { 
                // QI it for the interface
                Guid g = typeof(IProcessHostSupportFunctions).GUID; 
 
                int hresult = Marshal.QueryInterface(pUnk, ref g, out ppv);
                if (hresult < 0)  { 
                    Marshal.ThrowExceptionForHR(hresult);
                }

                // create a RCW we can hold onto in this domain 
                // this bumps the ref count so we can drop our refs on the raw interfaces
                localFunctions = (IProcessHostSupportFunctions)Marshal.GetObjectForIUnknown(ppv); 
            } 
            finally {
                // drop our explicit refs and keep the managed instance 
                if (IntPtr.Zero != ppv) {
                    Marshal.Release(ppv);
                }
                if (IntPtr.Zero != pUnk) { 
                    Marshal.Release(pUnk);
                } 
            } 

            return localFunctions; 
        }


        // Open ASP.NET's reg key, or one of its subkeys 
        internal static RegistryKey OpenAspNetRegKey(string subKey) {
            String ver = VersionInfo.SystemWebVersion; 
 
            // Zero out minor version number
 
            if (!string.IsNullOrEmpty(ver)) {
                int pos = ver.LastIndexOf('.');
                if (pos > -1) {
                    ver = ver.Substring(0, pos + 1) + "0"; 
                }
            } 
 
            // The main ASP.NET reg key
            string key = @"Software\Microsoft\ASP.NET\" + ver; 

            // If we're asked for a subkey, append it
            if (subKey != null)
                key += @"\" + subKey; 

            // Open and return the key 
            return Registry.LocalMachine.OpenSubKey(key); 
        }
 
        // Get an ASP.NET registry value, from the main key or a subkey
        internal static object GetAspNetRegValue(string subKey, string valueName, object defaultValue) {
            try {
                using (RegistryKey regKey = OpenAspNetRegKey(subKey)) { 

                    // Return the default value if the key doesn't exist 
                    if (regKey == null) 
                        return defaultValue;
 
                    return regKey.GetValue(valueName, defaultValue);
                }
            }
            catch { 
                // Return the default value if anything goes wrong
                return defaultValue; 
            } 
        }
    } 
}



// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.

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