Error occurs at runtime due to unexpected user input, environment dependencies and other reasons. You must take care of all known conditions that leads the application to crash. Crashes cause user frustration and decreases your reputation.

Even though you test your applications with all the effort you can give, still you can’t guarantee the software is 100% bug free. I bet, no one can!

When you deploy Windows GUI Applications on the end users machine, you lose control. Imagine a situation when your costumer reporting you of application crash and you wish you could capture all possible reasons of the crash. Even though you can get all user inputs and corresponding actions, that might not be enough.

Fortunately windows provides a set up utilities that can gather all environmental preconditions by capturing application data for that moment in a file. That is called dump (or memory dump).

The dump is a snapshot of the application (or systems memory) that can be used later for further analysis with debugging tools like windbg or Visual Studio. While you are in the development mode you start the process inside the visual studio (F5).

Visual Studio does various steps internally to connect to the process & maps executing system instructions with your source code with help of PDB files. If you set break point, the windows waits for signal from the debugger the proceed and shows you current state of different variables. If you are advanced developer you can make use of Local windows or Watch expressions to see and manipulate the values. This is easy since the processes memory is accessible to the debugger. But when you want to check the variables state at the time user reported an error from his/her machine is not that easy. The dump files comes rescue.

Generating dump of processes running under Windows Vista and newer operating system is simple.

As right clicking on the process in Windows Task Manager and Create Dump File

You can also use Windows API to generate Dumps when application crashes. Because after the crash the process may not be available any longer in the task manager.

BOOL WINAPI MiniDumpWriteDump(
  __in  HANDLE hProcess,
  __in  DWORD ProcessId,
  __in  HANDLE hFile,
  __in  MINIDUMP_TYPE DumpType,
  __in  PMINIDUMP_EXCEPTION_INFORMATION ExceptionParam,
  __in  PMINIDUMP_USER_STREAM_INFORMATION UserStreamParam,
  __in  PMINIDUMP_CALLBACK_INFORMATION CallbackParam
);

Equivalent C# API to call this native procedure is the following

[DllImport("DbgHelp.dll", SetLastError = true)]
private static extern bool MiniDumpWriteDump(IntPtr hProcess, int processId, SafeHandle fileHandle, int dumpType, IntPtr excepInfo, IntPtr userInfo, IntPtr extInfo);

Windows Applications provides global error handler event, that can be used to capture any unhandled exceptions from all threads.

You can subscribe to the event by wiring a global procedure in Program class. You should do this before running any other function.

Application.ThreadException += newSystem.Threading.ThreadExceptionEventHandler(Application_ThreadException);

You may invoke MiniDumpWriteDump procedure inside Application_ThreadException function as soon as any error occurs.

This helper function would write Dump file to the system temporary directory and the user may send the error report as an email attachment or upload to your website. Also note that the procedure generates full memory dump that can be used for debugging Managed Code. Full dump file size can be larger depending on the memory usage of the executing process.

internal static string WriteDump()
{
    using (Process process = Process.GetCurrentProcess())
    {
        string dumpFilePath = Path.Combine(Path.GetTempPath(), Application.ProductName + DateTime.Now.ToFileTimeUtc() + ".dmp");
        using (FileStream stream = new FileStream(dumpFilePath, FileMode.Create, FileAccess.ReadWrite))
        {
            Program.MiniDumpWriteDump(process.Handle, process.Id, stream.SafeFileHandle, 0x306, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
        }
        return dumpFilePath;
    }
}

Similarly in ASP.net Web Applications all unhandled exceptions can be logger from Global.asax in asp.net, similar to the following code snippet.

void Application_Error(object sender, EventArgs e) 
{ 
    Exception ex = Server.GetLastError();
    ExceptionManager.Log(ex); //...... Log error here.
    Server.Transfer(“DefaultError.aspx”);  
}

Also in WPF Applications

public partial class App : Application
{
    public App()
    {
        this.DispatcherUnhandledException += new DispatcherUnhandledExceptionEventHandler( App_DispatcherUnhandledException);
    }
}

You can find a sample code attached here for Handling crash and generating dump file.

You wont get intellisence and you may get warning in VS Error List that look like following :

Warning    1    Error updating JScript IntelliSense: C:\Users\someone\Documents\Visual Studio 2008\Projects\WebApplication1\WebApplication1\script\jquery-1.3.1.min.js: Object doesn't support this property or method @ 18:8308    C:\Users\someone\Documents\Visual Studio 2008\Projects\WebApplication1\WebApplication1\Default.aspx    1    1    WebApplication1

This is a bug in VS 2008 and you have a fix to this issue. You would require SP1 for Visual Studio 2008 before applying the hotfix.

Download from code.msdn.microsoft.com here.

https://code.msdn.microsoft.com/KB958502/Release/ProjectReleases.aspx?ReleaseId=1736

Once you are done, you are a happy programmer again !!

Did you ever wonder how AutoEventWireup="true" works in ASP.NET Pages? The page class basically hooks different generic event handler methods to the page life-cycle.
Such as Page_Load Method get’s called if present. OK!! It’s called using reflection.

public partial class_Default: System.Web.UI.Page
{
    protected voidPage_Load(objectsender, EventArgs e)
    {

    }
}

You can use a delegate or MethodInfo object to invoke method with a known signature. Here is a quick test that shows how do you do such in your code

Out test  :

using System;

namespace ConsoleApplication1
{
    class Program
    {
        delegate string TestMessageHandler(string s);

        static void Main(string[] args)
        {
            Delegate dl = Delegate.CreateDelegate(
                typeof(TestMessageHandler),
                typeof(Program),
                "SayHi");

            Console.WriteLine(dl.DynamicInvoke("Bill"));
            Console.ReadLine();
        }
        
        public static string SayHi(string name)
        {
            return "Welcome " + name;
        }        
    }
}

Even you can make this more strongly typed by casting the resulting Delegate object of Delegate.CreateDelegate  to the target delegate (TestMessageHandler)

Have fun..

Microsoft Listened!

Now you would  not need a Windows Server 2008 box to be able to develop applications for SharePoint with Visual Studio 2010. SharePoint Server Foundation (previously known as Windows SharePoint Services or WSS) on Windows 7 & Vista. Sorry XP guys :)

One constraint though, it has to be a x64 OS and you need to go through series of pre defined steps to enable these.

Visual Studio 2010 & SharePoint 2010 are good partner for sure.

Have you already started developing web apps on the new ASP.NET MVC framework? If yes, then you may be wondering how ASP.NET MVC framework works. Here is an walkthrough to dive you deep into the framework‘s internal concepts.

MVC framework is not new but one of the most popular design pattern for UI driven applications. Microsoft has created this wonderful support to allow you develop ASP.NET application based on MVC design patterns.

In order to complete this topic, you must have a working knowledge of ASP.NET Internals. (At least you understand how asp.net works). If not grab a copy of ASP.NET Internals and make yourself familiarized with the core framework.

In this exercise I will use a default MVC project created with ASP.NET MVC 1.0 Web Application project template. The core concept of MVC relies on HttpModule & HttpHandler. Although the article is reasonably lengthy, I have tried to cut code short by removing the part of the code out of discussion and keeping focus on highlighted portion.

When you open up the web.config file in the MVC project, you will notice a reference of HTTPHandler and HttpModule as highlighted below in the system.web/httpHandlers and httpModules.

We discussed about routing in little more details below.

web.config

    <system.web>

        <siteMap/>

        <compilation debug="true"/>

        <authentication mode="Windows" />

        <customErrors mode="Off"/>

        <pages>

            <controls/>

            <namespaces>

                <add namespace="System.Web.Mvc" />

                <add namespace="System.Web.Mvc.Ajax" />

                <add namespace="System.Web.Mvc.Html" />

                <add namespace="System.Web.Routing" />

            </namespaces>

        </pages>

        <httpHandlers>

            <remove verb="*" path="*.asmx" />

            <add verb="*" path="*.asmx" validate="false" type="System.Web.Script.Services.ScriptHandlerFactory, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" />

            <add verb="*" path="*_AppService.axd" validate="false" type="System.Web.Script.Services.ScriptHandlerFactory, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" />

            <add verb="GET,HEAD" path="ScriptResource.axd" type="System.Web.Handlers.ScriptResourceHandler, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" validate="false" />

            <add verb="*" path="*.mvc" validate="false" type="System.Web.Mvc.MvcHttpHandler, System.Web.Mvc, Version=1.0.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" />

        </httpHandlers>

        <httpModules>

            <add name="ScriptModule" type="System.Web.Handlers.ScriptModule, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" />

            <add name="UrlRoutingModule" type="System.Web.Routing.UrlRoutingModule, System.Web.Routing, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" />

        </httpModules>

    </system.web>

The below routing map sample can be found in the default Global.asax file. ASP.NET MVC applications typically register controller routes in Application_Start event of Global.asax.

Global.asax

    public class MvcApplication : System.Web.HttpApplication

    {

        public static void RegisterRoutes(RouteCollection routes){

            routes.IgnoreRoute("{resource}.axd/{*pathInfo}");

            routes.MapRoute(

                "Default",                                              // Route name

                "{controller}/{action}/{id}",                           // URL with parameters

                new { controller = "Home", action = "Index", id = "" }  // Parameter defaults

            );

        }

        protected void Application_Start(){

            RegisterRoutes(RouteTable.Routes);

        }

    }

You make use of RouteCollectionExtensions to simplify the task of route mapping. When you use route.MapRoute, actually you add new Route instance of MVCRouteHandler type. Although Routing is part of ASP.NET 3.5 Extension, MVC is not. So you must add an assembly reference of System.Web.Mvc to get access to this extension & MvcRouteHandler.

RouteCollectionExtensions

    public static class RouteCollectionExtensions

    {

        public static void IgnoreRoute(this RouteCollection routes, string url);

        public static void IgnoreRoute(this RouteCollection routes, string url, object constraints);

        public static Route MapRoute(this RouteCollection routes, string name, string url);

        public static Route MapRoute(this RouteCollection routes, string name, string url, object defaults);

        public static Route MapRoute(this RouteCollection routes, string name, string url, string[] namespaces);

        public static Route MapRoute(this RouteCollection routes, string name, string url, object defaults, object constraints);

        public static Route MapRoute(this RouteCollection routes, string name, string url, object defaults, string[] namespaces);

        public static Route MapRoute(this RouteCollection routes, string name, string url, object defaults, object constraints, string[] namespaces) {

            if (routes == null) {

                throw new ArgumentNullException("routes");

            }

            if (url == null) {

                throw new ArgumentNullException("url");

            }

            Route item = new Route(url, new MvcRouteHandler()){

                Defaults = new RouteValueDictionary(defaults),

                Constraints = new RouteValueDictionary(constraints)

            };

            if ((namespaces != null) && (namespaces.Length > 0)) {

                item.DataTokens = new RouteValueDictionary();

                item.DataTokens["Namespaces"] = namespaces;

            }

            routes.Add(name, item);

            return item;

        }

        private sealed class IgnoreRouteInternal : Route

        {

            public IgnoreRouteInternal(string url);

            public override VirtualPathData GetVirtualPath(RequestContext requestContext, RouteValueDictionary routeValues);

        }

    }

URL Routing Module

The key part of routing happens in the PostMapRequestHandler, PostResolveRequestCache(In case of cached results) events of the HttpModule.

1.       It finds specific Route by matching the request context. The matching works based on different factors such as the url & input parameters.

2.       Then it tries to retreive the RouteHandler from the Route.

3.       And this inturn sets the HttpContext.Handler to new instance of IHttpHandler from IRouteHandler.

    public class UrlRoutingModule : IHttpModule

    {

        static UrlRoutingModule();

        public UrlRoutingModule();

        protected virtual void Dispose();

        protected virtual void Init(HttpApplication application);

        private void OnApplicationPostMapRequestHandler(object sender, EventArgs e);

        private void OnApplicationPostResolveRequestCache(object sender, EventArgs e);

        /// <summary>

        /// Assigns the HTTP handler for the current request to the context.

        /// </summary>

        public virtual void PostMapRequestHandler(HttpContextBase context) {

            RequestData data = (RequestData)context.Items[_requestDataKey];

            if (data != null) {

                context.RewritePath(data.OriginalPath);

                context.Handler = data.HttpHandler;

            }

        }

        /// <summary>

        /// Matches the HTTP request to a route, retrieves the handler for that route, and sets the handler as the HTTP handler for the current request.

        /// </summary>

        public virtual void PostResolveRequestCache(HttpContextBase context) {

            RouteData routeData = this.RouteCollection.GetRouteData(context);

            if (routeData != null) {

                IRouteHandler routeHandler = routeData.RouteHandler;

                if (routeHandler == null) {

                    throw new InvalidOperationException(string.Format(CultureInfo.CurrentUICulture, RoutingResources.UrlRoutingModule_NoRouteHandler, new object[0]));

                }

                if (!(routeHandler is StopRoutingHandler)) {

                    RequestContext requestContext = new RequestContext(context, routeData);

                    IHttpHandler httpHandler = routeHandler.GetHttpHandler(requestContext);

                    if (httpHandler == null) {

                        throw new InvalidOperationException(string.Format(CultureInfo.CurrentUICulture, RoutingResources.UrlRoutingModule_NoHttpHandler, new object[] { routeHandler.GetType() }));

                    }

                    context.Items[_requestDataKey] = new RequestData { OriginalPath = context.Request.Path, HttpHandler = httpHandler };

                    context.RewritePath("~/UrlRouting.axd");

                }

            }

        }

        /// <summary>

        /// Initializes a module and prepares it to handle requests.

        /// </summary>

        /// <param name="application">

        /// An object that provides access to the methods, properties, and events common to all application objects in an ASP.NET application.

        /// </param>

        protected virtual void Init(HttpApplication application) {

            application.PostResolveRequestCache += new EventHandler(this.OnApplicationPostResolveRequestCache);

            application.PostMapRequestHandler += new EventHandler(this.OnApplicationPostMapRequestHandler);

        }

        public RouteCollection RouteCollection { get; set; }

        private class RequestData

        {

            public IHttpHandler HttpHandler { get; set; }

            public string OriginalPath { get; set; }

        }

    }

MVCRouteHandler created new instance of MVCHandler when requested through GetHttpHandler method.

MvcRouteHandler

    public class MvcRouteHandler : IRouteHandler

    {

        // Methods

        protected virtual IHttpHandler GetHttpHandler(RequestContext requestContext) {

            return new MvcHandler(requestContext);

        }

    }

Here is magic. ASP.NET Runtime pipeline calles the ProcesRequest method of MvcHandler (HttpHandler)

MvcHandler

    public class MvcHandler : System.Web.IHttpHandler, IRequiresSessionState

    {

        private ControllerBuilder _controllerBuilder;

        static MvcHandler();

        public MvcHandler(RequestContext requestContext);

        protected virtual void ProcessRequest(HttpContext httpContext) {

            HttpContextBase base2 = new HttpContextWrapper(httpContext);

            this.ProcessRequest(base2);

        }

        protected internal virtual void ProcessRequest(HttpContextBase httpContext) {

            this.AddVersionHeader(httpContext);

            string requiredString = this.RequestContext.RouteData.GetRequiredString("controller");

            IControllerFactory controllerFactory = this.ControllerBuilder.GetControllerFactory();

            IController controller = controllerFactory.CreateController(this.RequestContext, requiredString);

            if (controller == null) {

                throw new InvalidOperationException(

                    string.Format(CultureInfo.CurrentUICulture, MvcResources.ControllerBuilder_FactoryReturnedNull,

                    new object[] { controllerFactory.GetType(), requiredString }));

            }

            try{

                controller.Execute(this.RequestContext);

            }

            finally{

                controllerFactory.ReleaseController(controller);

            }

        }

        protected virtual bool IsReusable{

            get{return false;}

        }

        public RequestContext RequestContext { get; private set; }

        internal ControllerBuilder ControllerBuilder{

            get{

                if (this._controllerBuilder == null) {

                    this._controllerBuilder = ControllerBuilder.Current;

                }

                return this._controllerBuilder;

            }

            set{

                this._controllerBuilder = value;

            }

        }

    }