Misc.cs source code in C# .NET

                        Code:
                         / 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / xsp / System / Web / Util / Misc.cs / 1305376 / 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) {
            UnsafeNativeMethods.ReportUnhandledException(FormatExceptionMessage(e, strings)); 
        }

        internal static String FormatExceptionMessage(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);
            } 

            return sb.ToString();
        }
 
        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 VSWhidbey 602541 
            // Eg. 2.0.50727.42 becomes 2.0.50727.0
            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.
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
Misc.cs source code in C# .NET

Source code for the .NET framework in C#

Code:

Link Menu
