/// <summary>
/// Converts a number value into a string that represents the number 
/// expressed in whole kilobytes. This is a format similar to the 
///	Windows Explorer "Size" column.
/// </summary>
public static string FileSizeToStringKB(long fileSize)
{
	return string.Format("{0:n0} KB", Math.Ceiling((double)fileSize / 1024));
}
 
 
/// <summary>
/// Converts a numeric value into a string that represents the number 
///	expressed as a size value in bytes, kilobytes, megabytes, gigabytes, 
///	or terabytes depending on the size. Output is identical to 
///	StrFormatByteSize() in shlwapi.dll. This is a format similar to 
/// the Windows Explorer file Properties page. For example:
///	     532 ->  532 bytes
///     1240 -> 1.21 KB
///	  235606 ->  230 KB
///  5400016 -> 5.14 MB
/// </summary>
/// <remarks>
///	It was surprisingly difficult to emulate the StrFormatByteSize() function
/// due to a few quirks. First, the function only displays three digits:
///  - displays 2 decimal places for values under 10	(e.g. 2.12 KB)
///  - displays 1 decimal place for values under 100	(e.g. 88.2 KB)
///	 - displays 0 decimal places for values under 1000	(e.g. 532 KB)
///	 - jumps to the next unit of measure for values over 1000  (e.g. 0.97 MB)
/// The second quirk: insiginificant digits are truncated rather than 
/// rounded. The original function likely uses integer math.
/// This implementation was tested to 100 TB.
/// </remarks>
public static string FileSizeToString(long fileSize)
{
	double value;
	string unit;
 
	if (fileSize < 1024)
	{
		return string.Format("{0} bytes", fileSize);
	}
	else 
	{
		value = fileSize;
		value = value / 1024;
		unit = "KB";
		if (value >= 1000)
		{
			value = Math.Floor( value );
			value = value / 1024;
			unit = "MB";
		}
		if (value >= 1000)
		{
			value = Math.Floor( value );
			value = value / 1024;
			unit = "GB";
		}
		if (value >= 1000)
		{			value = Math.Floor( value );
			value = value / 1024;
			unit = "TB";
		}
 
		if (value < 10)
		{
			value = Math.Floor( value * 100 ) / 100;
			return string.Format("{0:f2} {1}", value, unit);
		}
		else if (value < 100)
		{
			value = Math.Floor( value * 10) / 10;
			return string.Format("{0:f1} {1}", value, unit);
		}
		else
		{
			value = Math.Floor( value * 1) / 1;
			return string.Format("{0:f0} {1}", value, unit);
		}
	}
}

<ADPLUS>
  <SETTINGS>
   <RUNMODE>CRASH</RUNMODE>
  </SETTINGS>
  <PRECOMMANDS>
   <CMD>!load clr10\sos</CMD>
  </PRECOMMANDS>
  <EXCEPTIONS>
   <OPTION>NoDumpOnFirstChance</OPTION>
   <OPTION>NoDumpOnSecondChance</OPTION>
   <CONFIG><!-- This is for the CLR exception -->
    <CODE>clr</CODE>
    <ACTIONS1>Log</ACTIONS1>
    <CUSTOMACTIONS1>!cen;!clrstack;.dump /ma /u c:\exceptiondump.dmp;gn </CUSTOMACTIONS1>
    <RETURNACTION1>GN</RETURNACTION1>
   </CONFIG>
  </EXCEPTIONS>
</ADPLUS>

using System;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;
using System.Web;
 
namespace WebMonitor {
    public class UnhandledExceptionModule: IHttpModule {
 
        static int _unhandledExceptionCount = 0;
 
        static string _sourceName = null;
        static object _initLock = new object();
        static bool _initialized = false;
        static string _mailServer = "mymailserver";
        static string _mailTo = "abc@xyz.com";
 
        public void Init(HttpApplication app) {
 
            // Do this one time for each AppDomain.
            if (!_initialized) {
                lock (_initLock) {
                    if (!_initialized) { 
 
                        _sourceName = string.Format(CultureInfo.InvariantCulture, "ASP.NET {0}.{1}.{2}.0",
							System.Environment.Version.Major, 
							System.Environment.Version.Minor,
							System.Environment.Version.Build);
 
                        if (!EventLog.SourceExists(_sourceName)) {
                            throw new Exception(String.Format(CultureInfo.InvariantCulture,
                                                              "There is no EventLog source named '{0}'.", 
                                                              _sourceName));
                        }
 
                        AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(OnUnhandledException);
 
                        _initialized = true;
 
						LogMessage("UnhandledExceptionModule started", "", EventLogEntryType.Information);
 
                    }
                }
            }
        }
 
        public void Dispose() {
        }
 
        void OnUnhandledException(object o, UnhandledExceptionEventArgs e) {
            // Let this occur one time for each AppDomain.
            if (Interlocked.Exchange(ref _unhandledExceptionCount, 1) != 0)
                return;
 
            StringBuilder message = new StringBuilder("\r\n\r\nUnhandledException logged by UnhandledExceptionModule.dll:\r\n\r\nappId=");
 
            string appId = (string) AppDomain.CurrentDomain.GetData(".appId");
            if (appId != null) {
                message.Append(appId);
            }
 
            Exception currentException = null;
            for (currentException = (Exception)e.ExceptionObject; currentException != null; currentException = currentException.InnerException) {
                message.AppendFormat("\r\n\r\ntype={0}\r\n\r\nmessage={1}\r\n\r\nstack=\r\n{2}\r\n\r\n",
                                     currentException.GetType().FullName, 
                                     currentException.Message,
                                     currentException.StackTrace);
            }           
 
			LogMessage("UnhandledExceptionModule exception", message.ToString(), EventLogEntryType.Error);
        }
 
		void LogMessage(string subject, string message, EventLogEntryType severity)
		{
			try
			{
				EventLog Log = new EventLog();
				Log.Source = _sourceName;
				Log.WriteEntry(subject + "\n" + message, severity);
			}
			catch  {}
			try
			{
				System.Web.Mail.MailMessage msg = new System.Web.Mail.MailMessage();
				msg.Body = message;
				msg.To = _mailTo;
				msg.Subject = severity.ToString() + ": " + subject;
				msg.From = _mailTo;
 
				System.Web.Mail.SmtpMail.SmtpServer = _mailServer;
				System.Web.Mail.SmtpMail.Send(msg);
			}
			catch {}
		}
 
    }
}

<system.web>
  <httpModules>
    <add type="WebMonitor.UnhandledExceptionModule, UnhandledExceptionModule" name="UnhandledExceptionModule"/>
  </httpModules>
</system.web>

using System.Threading;
Timer t;
private void btnTest_Click(object sender, System.EventArgs e)
{
  t = new Timer(new TimerCallback(t_Elapsed), null, 250, Timeout.Infinite);
}
private void t_Elapsed(object state)
{
  throw new Exception("My unhandled exception");
}

Grid.Bands(0).RowStyle.BackColor = Color.LightGray
Grid.Bands(0).RowStyle.ForeColor = Color.DarkGray
Grid.Bands(0).RowAlternateStyle = Grid.Bands(0).RowStyle
Grid.Bands(0).SelectedRowStyle = Grid.Bands(0).RowStyle
Grid.Bands(0).HeaderStyle.ForeColor = Color.DarkGray
Grid.BackColor = Color.LightGray
Grid.DisplayLayout.ClientSideEvents.BeforeSelectChangeHandler = "Grid_BeforeSelectChange"
Grid.DisplayLayout.ClientSideEvents.BeforeRowActivateHandler = "Grid_BeforeRowActivate"

  <script language="javascript">
    // Prevent the user from changing the currently active row
    function Grid_BeforeRowActivate(gridName, id)
    {
        igtbl_cancelPostBack(gridName);
        return 1;
    }
    // Prevent the user from changing the currently selected row
    function Grid_BeforeSelectChange(gridName, id)
    {
        igtbl_cancelPostBack(gridName);
        return 1;
    }
    </script>

Grid.Bands(0).RowStyle = Grid.DisplayLayout.RowStyleDefault
Grid.Bands(0).RowAlternateStyle = Grid.DisplayLayout.RowAlternateStyleDefault
Grid.Bands(0).SelectedRowStyle = Grid.DisplayLayout.SelectedRowStyleDefault
Grid.Bands(0).HeaderStyle = Grid.DisplayLayout.HeaderStyleDefault
Grid.BackColor = Color.Transparent
Grid.DisplayLayout.ClientSideEvents.BeforeSelectChangeHandler = ""
Grid.DisplayLayout.ClientSideEvents.BeforeRowActivateHandler = ""

<system.diagnostics> 
	<trace autoflush="true" indentsize="4"> 
			<listeners> n
			<add 	name="FileListener" 
				type="System.Diagnostics.TextWriterTraceListener" 
				initializeData="TraceLog2.txt" /> 
		</listeners> 
	</trace> 
</system.diagnostics>

public static DateTime PasswordExpirationDate(string user, string domain)
{
	string connect = String.Format("WinNT://{0}/{1},user", domain, user);
	DirectoryEntry entry = new DirectoryEntry(connect);
 
	if (entry == null)
		Console.WriteLine("Failed to get Directory Entry.");
 
	int secondsRemaining = (int)entry.Properties["MaxPasswordAge"][0];
 
	// A policy setting of -1 means no expiration,
	// so return an 'infinite' date
	if (secondsRemaining > 0) 
	{
		secondsRemaining -= (int)entry.Properties["PasswordAge"][0];
		return DateTime.Now.AddSeconds(secondsRemaining);
	} 
	else 
	{ 
		return DateTime.MaxValue; 
	}
}