Dispose Vs Finalize

Dispose method is mainly controlled by the developer, and it frees all the resource upon the completion of the event. While Finalize method is controlled by the Garbage Collector(GC) and there is no predictability as to when the GC will call the finalize method to free the resources.


Finalize method cannot be overridden or called explicitly. It is basically used for implicit resource clean-up.


C# provides a USING statement , which ensures that Dispose() method will be called at the earliest possible time (Dispose method is automatically called if the class implements IDisposable and used in USING statement).

IDisposable Interface (Disposable Pattern)

Introduction:
    IDisposable Interface is primarily designed to provide a standard way to manage the unmanged resources in the .net applications.
  
Description:
    We know that Garbage Collector(GC) is designed to manage memory allocation in .net applications. So developer have no headache to manage the managed resources as GC manage it implicitly. But when it comes about the unmanaged resources GC have no control over it, because GC is not designed to deal with unmanaged resources, so it is the developers responsibility to manage this unmanaged resources.
   A developer can achieve this by overriding the Finalize method, but the problem with finalize method is that as Garbage Collector does not run in deterministically and in result the object may be wait for finalization for a longer period of time. And this situation becomes more complected if our object is using expensive resources like database connection or file handles, then waiting a long period of time to free these resource is not acceptable. To avoid this waiting of Garbage Collection for an indeterminate amount of time to free resource Disposable Pattern (IDisposable pattern) is used.
      
This Disposable Pattern/IDisposable Interface is basically designed to ensure predictable and reliable cleanup of resource to prevent resource leak and to provide a standard pattern for disposable classes. IDisposable interface defines a single method called Dispose() that need to be implemented by the implemented class. And the developers have to ensure that they implements clean up code using this method.

Example:

   public class MyDisposableClass : IDisposable
    {
        private bool isDisposted = false;

        ~MyDisposableClass()
        {
            Dispose(false);
        }

        public void Dispose()
        {
            Dispose(true);
        }

        private void Dispose(bool disposing)
        {
            if (!isDisposted)
            {
                if (disposing)
                {
                    //TODO: Wtire your clean up code here
                   
                    //This will remove the object from the finalization queue as the clean up
                    //is already done and finaliztion is not required.
                    GC.SuppressFinalize(this);

                }
                // flag set to ture as dispose is done
                isDisposted = true;
            }
        }
    }

HTTP Modules Vs Global.asax File

Differences:

    If you view the functionality provided by the HTTP Modules and the Global.asax file you find both are almost similar, But the advantage of using the HTTP Module over Global.aspx file is that they can be re-used by adding them to the GAC (Global Assembly Cache) and registering in the Machine.config file you can use it across all the application running on that server, while global.asax files are application specific.

   And the advantage of using Global.asax file over HTTP Modules is that it provides some extra events that can not be available during  in the HTTP Module implementation. Those events are :

                            1. Application_start

                            2. Session_Start

                            3. Session_End

                            4. Application_End

Along with this Global.asax also enables you to declare and initialize your global objects in your application. 

Another difference is that you can have one Global.asax file in your application and you have to implement all your required logic on that, But in the case of HTTP Module you can divide your required logic in different modules and can have more than one HTTP Module attached in your application.

MVP Design Pattern Implementation using ASP.NET/Win Form

Introduction:
    We have given a task to implement our next project in two different interfaces, One using traditional ASP.NET web pages and another one using the new rich silver-light user interface . And we have to follow the MVP design pattern to implement this. During this process I have gone through the MVP design pattern documents and implementation processes and writing this blog to provide a little bit introductory idea about what is MVP pattern and a simple example to implement this using a web and windows application.


    I have not used the silver-light in this example, because CLR for web application and silver-light CLR are completely different. To implement this you have to develop separate set of view, presenter and model component for web application and for silver-light. There is a trick to solve this by developing the different components for Web application  first and later adding parallel components for silver-light by just adding the link of all the classes and interfaces developed for respective web application components. But my main purpose is to focus on the MVP pattern, so i have taken a example of windows application in place of silver-light.

Description:
MVP pattern stand for Model-View-Presenter design pattern. It is basically built of using three components View, Model and Presenter. It is a derivative of the MVC (Model-View-Control) pattern. 

Model-View-Presenter Pattern

View: It represents the applications presentation layer and responsible for displaying and receiving the user inputs  and handling the user events (i.e. mouse clicks, key down, click etc.) on the controls only. Views does not call directly to the  Models, Instead it invokes the Presenter methods which in-turn calls the Model to get the data and in return updates the view. All concrete view components must implement an interface which defines all the methods and properties which required to be implemented.



Presenter: This component basically communicates with the view to accept user inputs for processing, connect to the model to retrieve the required data or process the requested  business logic and return the view the desired data to show. Presenter have access to the interface of the view. It has no idea about the implementation.


Model: It contains all the business logic of the application. It processes the request from the presenter and do the processing to return it's result to the presenter.


Implementation:
    To describe MVP implementation using asp.net i have created a small application (for giving a general idea of implementation) that search employee by employee code and display employee information on the page. At this moment i have not implemented any logic at model level and just returning a hard coded value for testing purpose. Later we have used the model, view and presenter to implement the same functionality on a windows application without making any change on the core components (Model, View and Presenter).

Implementation Using ASP.NET (Web Page)

Implementation using Windows Application (Win Form)

Creating & Implementing View in Web and Windows application:
   View is basically defines an interface which need to be implemented by the UI layer. This interface is later used by the presenter. This provides the way to lose coupling between view and presenter. Here I have created an interface called IEmpView. This is the interface that is going to be implemented by both the web application and windows application.

Code (IEmpView):

  public interface IEmpView
    {
        string Code { get; }
        string EmpName { set;  }
        string Address { set; }
    }

  
Code (Aspx page code behind): 
  In the code behind of the web application we have implemented the IEmpView interface and implemented the properties exposed by it. And in the Click event of the search button it instantiate the presenter class and call the required method for processing.

  public partial class EmployeeInfo : System.Web.UI.Page, IEmpView
    {
        public string Code
        {
            get  { return txtCode.Text ; }
        }

        public string EmpName
        {
            set { lblName.Text = value; }
        }

        public string Address
        {
            set { lblAddress.Text = value; }
        }

        protected void btnSearch_Click(object sender, EventArgs e)
        {
            mvpPresenter.EmpPresenter empPresenter = new mvpPresenter.EmpPresenter(this);
            empPresenter.BindData();
        }
    }

Code (Windows application):
    In this section i have used the same interface to develop the application using Windows Form. Similar like the above implementation in web form the windows form implements the IEmpView and implements the properties.

     public partial class EmployeeForm : Form, IEmpView
    {
        public string Code
        {
            get { return txtCode.Text; }
        }

        public string EmpName
        {
            set { lblName.Text = value;}
        }

        public string Address
        {
            set { lblAddress.Text = value; }
        }        

        private void btnSearch_Click(object sender, EventArgs e)
        {
            mvpPresenter.EmpPresenter empPresenter = new mvpPresenter.EmpPresenter(this);
            empPresenter.BindData();
        }

    }

Creating the Presenter:
    Presenter have no idea about the UI. It does not know the view interface it is interacting is implemented by a windows or web application.Its constructor takes the IEmpView (interface) as parameter.

Code (Presenter):

    public class EmpPresenter
    {
        private readonly IEmpView empView;

        public EmpPresenter(IEmpView view)
        {
            empView = view;
        }

        public void BindData()
        {
            EmpModel model = new EmpModel();
            EmpDTO employee = model.GetEmployee(empView.Code);
            empView.EmpName = employee.Name;
            empView.Address = employee.Address;
        }
    }

This is the DTO class I have used to transfer data between the Model and Presenter.

Code (Employee DTO): 

    public class EmpDTO
    {
        public string Code { set; get; }
        public string Name { set; get; }
        public string Address { set; get; }
        public EmpDTO(string code, string name, string address)
        {
            Code = code;
            Name = name;
            Address = address;
        }
    }

Creating Model: 
    Model class basically holds the business logic of the application. In this example i have hard coded the process logic of GetEmployee() method and it will be replaced by the code to fetch data from database or some external source by communicating with the respective layer.

Code (Interface of Model):

 public interface IEmpModel
    {
        EmpDTO GetEmployee(string empCode);
    }

Code (Concrete Model Class):

    public class EmpModel:IEmpModel
    {
        public EmpModel()
        {
        }

        public EmpDTO GetEmployee(string empCode)
        {
            return new EmpDTO(empCode, "Prasant Swain", "Kolkata");
        }
    }

So you have noticed that we have implemented our application using different UI without modifying our core components (Model, View and Presenter).



Advantages:
1. Provide the ability to test all the code in the application except the visual appearance and the interaction.
2. Ability to interchange view without modification on the code (Example. it can be easily changed the presentation layer from the web page to a windows form without modification in the core components ( Presenter and Model Component.).
3. It simplifies the testing process.

Steps to create a HTTP Handler

Description:
    In this article I am just trying to writing down the steps with code example (C#) to create a simple custom HTTP handler. and configure it on IIS 5.1. The detail description about the HTTP Handler are described on this blog "HTTP Handlers (ASP.NET)"


Step 1: Creation of Handler:
     1. Create a web application (in this example i have created with name HTTPHandlerTest).
     2. Add a class to (I have used MyTestHandler in this example) your application and implement the IHttpHandler Interface. You can also implement the IRequireSessionState Interface if you want to access the session and IReadOnlySessionState if you want to access session data in read only mode.
     3. Implement the ProcessRequest() method and IsReusable Property. IsReusable property  determines whether the handler is pooled or not. If it returns true then the handler is kept on the pool for further user and the ProcessRequest() method to the processing.

    4. Modify the web.config file to register the handler. In this example i have registered the handler to process the the files having extension .test.



<httpHandlers>
    <add verb="*" path="*.test" type="HTTPHandlerTest.MyTestHandler, HTTPHandlerTest"/>
</httpHandlers>


Step 2: Configure the IIS 5.1
     1. Open the Internet Information Services (Control Panel--> Administrative Tool-->Internet Information Services).
     2. Go to "Default Web Site", Right click on it and open Properties.
     3. On the Properties window click on the "Home Directory" tab and click on the "Configuration" Button.
     4. Click on the "Add" button to register the new mapping. 
         In the Executable text box browse the path of the "aspnet_isapi.dll" files location on your machine (i.e. C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\aspnet_isapi.dll) and in the Extension text box enter the extension of the file that is going to process (i.e. i have used .test extension). Press OK to save setting.

Step 3: Testing Your Handler
    1. Add a file with extension .test to your application to test the application (I have added a file called MyTest.test to test it).
    2. Run the application and type "http://localhost:4611/MyTest.test" as URL.