Friday, 26 December 2014

Custom Filters in MVC

~ Custom Filters in MVC - Authorization , Action, Result, Exception Filters ~

Filters in MVC are attributes which you can apply to a controller action or an entire controller. This will allow us to add pre and post behavior to controller action methods.



There are 4 types of Filters. Which were described in above image.

Step 1: Create a simple MVC Web application. Lets see the Output Cache filter first.
I created a View and pertaining Action method. See them below.

ACTION METHOD
        /// <summary>
        /// OutputCache Test
        /// </summary>
        /// <returns></returns>
        [OutputCache(Duration = 10)]
        public ActionResult OutPutTest()
        {
            ViewBag.Date = DateTime.Now.ToString("T");
            return View();
        }

VIEW
@{
    ViewBag.Title = "OutPutTest";
}
<h2>OutPutTest</h2>

<h3>@ViewBag.Date</h3>


Output : so as per the current implementation, the view should be displaying current time with seconds. so for every refresh, the seconds part will be changed...
But observe the [OutputCache(Duration=10)] attribute applied to action method. This will make the response cached for 10 seconds. Thus the seconds part will not be changed for next 10 seconds.


Step 2: Authorization Filter : This filter will be executed once after user is authenticated
In this step lets create a custom Authorization filter. For this create a class which inherits AuthorizeAttribute or implements IAuthorizationFilter interface. All we are doing here is just passing a message to View.

    public class CustAuthFilter : AuthorizeAttribute
    {
        public override void OnAuthorization(AuthorizationContext filterContext)
        {
            filterContext.Controller.ViewBag.AutherizationMessage = "Custom Authorization: Message from OnAuthorization method.";
        }
      }

Now we have our CustomAuthFilter which will be executed immedealty after user is authenticated. But inorder to make it happen we need to apply this [CustAuthFilter] attribute on top either a custom action or to an entire controller itself.

ACTION METHOD
        /// <summary>
        /// Custom Authorization Filter Test
        /// </summary>
        /// <returns></returns>
        [CustAuthFilter]
        public ActionResult AuthFilterTest()
        {
            return View();
        }
 VIEW
@{
    ViewBag.Title = "AuthFilterTest";
}

<h2>AuthFilterTest</h2>

<h3>@ViewBag.AutherizationMessage</h3>

We have another method OnUnauthorizedRequest event to redirect the unauthorized users to some default pages. 

OUTPUT:  


Step 3: Action Filter : There are 4 events available in an action filter.
  1. OnActionExecuting - Runs before execution of Action method.
  2. OnActionExecuted - Runs after execution of Action method.
  3. OnResultExecuting - Runs before content is rendered to View.
  4. OnResultExecuted - Runs after content is rendered to view.
So lets create a CustomActionFilter. Create a class inherting ActionFilterAttribute class of implementing IActionFilter and IResultFilter interfaces.

public class CustomActionFilter : ActionFilterAttribute
    {
        public override void OnActionExecuting(ActionExecutingContext filterContext)
        {
            filterContext.Controller.ViewBag.CustomActionMessage1 = "Custom Action Filter: Message from OnActionExecuting method.";
        }

        public override void OnActionExecuted(ActionExecutedContext filterContext)
        {
            filterContext.Controller.ViewBag.CustomActionMessage2 = "Custom Action Filter: Message from OnActionExecuted method.";
        }

        public override void OnResultExecuting(ResultExecutingContext filterContext)
        {
            filterContext.Controller.ViewBag.CustomActionMessage3 = "Custom Action Filter: Message from OnResultExecuting method.";
        }

        public override void OnResultExecuted(ResultExecutedContext filterContext)
        {
            filterContext.Controller.ViewBag.CustomActionMessage4 = "Custom Action Filter: Message from OnResultExecuted method.";
        }       
    }

Now all we need to do is to apply [CustomActionFilter] attribute on an Action Method.

ACTION METHOD
        /// <summary>
        /// Custom Action Filters Test
        /// </summary>
        /// <returns></returns>
        [CustomActionFilter]
        public ActionResult ActionFilterTest()
        {
            return View();
        }

VIEW
@{
    ViewBag.Title = "ActionFilterTest";
}

<h2>ActionFilterTest</h2>
<br />

<br />
<h3>@ViewBag.CustomActionMessage1</h3>
<br />
<h3>@ViewBag.CustomActionMessage2</h3>
<br />
<h3>@ViewBag.CustomActionMessage3</h3>
<br />
<h3>@ViewBag.CustomActionMessage4</h3>

OUTPUT:  


Step 4: Exception Filter: This filter is used to capture any execptions if raised by controller or an action method. Create a class which will inherit FilterAttribute class and implement IExceptionFilter interface.

    public class CustExceptionFilter : FilterAttribute, IExceptionFilter
    {
        public void OnException(ExceptionContext filterContext)
        {
            filterContext.Controller.ViewBag.ExceptionMessage = "Custom Exception: Message from OnException method.";
        }
    }
Now all we need to do to handle any exceptions or erros is to apply [CustExceptionFilter] attribute on an Action Method.

ACTION METHOD
        /// <summary>
        /// Custom Exception Filter Test
        /// </summary>
        /// <returns></returns>
        [CustExceptionFilter]
        public ActionResult ExceptionFilterTest()
        {
            return View();
        }

VIEW
@{
    ViewBag.Title = "ExceptionFilterTest";
}

<h2>ExceptionFilterTest</h2>
<br />
<h3>@ViewBag.ExceptionMessage</h3>

OUTPUT: 

Now compare the output with the view definition and see the differences.

First thing is , we dint have any message from OnResultExecuted event.

Reason: That event will be executed after content is rendered to view, so by that time the view is rendered, OnResultExecuted event is not and message is not yet assigned to ViewBag.

Second thing, we dint have any message from exception filter. If there is any exception raised by the code, then the Exception Filter codee will come into picture. With this , we have covered different kinds of filters in MVC and how to create custom filters and how to apply them.
Download the Required Files for this Project  - Click here

Is it helpful for you? Kindly let me know your comments / Questions.
Continue Reading →

Thursday, 11 December 2014

Lazy Loading and Eager Loading

~Difference between Lazy Loading and Eager Loading~

In LINQ and Entity Framework, you have Lazy Loading and Eager Loading for loading the related entities of an entity. In this article you will learn the differences between these two loading.

Lazy/Deferred Loading

       In case of lazy loading, related objects (child objects) are not loaded automatically with its parent object until they are requested. By default LINQ supports lazy loading.

For Example:

var query = context.Categories.Take(3); // Lazy loading

foreach (var Category in query)
{
 Console.WriteLine(Category.Name);
 foreach (var Product in Category.Products)
 {
 Console.WriteLine(Product.ProductID);
 }

 }

Generated SQL Query will be:

SELECT TOP (3)
[c].[CatID] AS [CatID],
[c].[Name] AS [Name],
[c].[CreatedDate] AS [CreatedDate]
FROM [dbo].[Category] AS [c]
GO

-- Region Parameters
DECLARE @EntityKeyValue1 Int = 1
-- EndRegion
SELECT
[Extent1].[ProductID] AS [ProductID],
[Extent1].[Name] AS [Name],
[Extent1].[UnitPrice] AS [UnitPrice],
[Extent1].[CatID] AS [CatID],
[Extent1].[EntryDate] AS [EntryDate],
[Extent1].[ExpiryDate] AS [ExpiryDate]
FROM [dbo].[Product] AS [Extent1]
WHERE [Extent1].[CatID] = @EntityKeyValue1
GO

-- Region Parameters
DECLARE @EntityKeyValue1 Int = 2
-- EndRegion
SELECT
[Extent1].[ProductID] AS [ProductID],
[Extent1].[Name] AS [Name],
[Extent1].[UnitPrice] AS [UnitPrice],
[Extent1].[CatID] AS [CatID],
[Extent1].[EntryDate] AS [EntryDate],
[Extent1].[ExpiryDate] AS [ExpiryDate]
FROM [dbo].[Product] AS [Extent1]
WHERE [Extent1].[CatID] = @EntityKeyValue1
GO

-- Region Parameters
DECLARE @EntityKeyValue1 Int = 3
-- EndRegion
SELECT
[Extent1].[ProductID] AS [ProductID],
[Extent1].[Name] AS [Name],
[Extent1].[UnitPrice] AS [UnitPrice],
[Extent1].[CatID] AS [CatID],
[Extent1].[EntryDate] AS [EntryDate],
[Extent1].[ExpiryDate] AS [ExpiryDate]
FROM [dbo].[Product] AS [Extent1]
WHERE [Extent1].[CatID] = @EntityKeyValue1


 In above example, you have 4 SQL queries which means calling the database 4 times, one for the Categories and three times for the Products associated to the Categories. In this way, child entity is populated when it is requested.
       You can turn off the lazy loading feature by setting LazyLoadingEnabled property of the ContextOptions on context to false. Now you can fetch the related objects with the parent object in one query itself.

context.ContextOptions.LazyLoadingEnabled = false;

Eager loading
       In case of eager loading, related objects (child objects) are loaded automatically with its parent object. To use Eager loading you need to use Include() method.

For Example:
var query = context.Categories.Include("Products").Take(3); // Eager loading

 foreach (var Category in query)
 {
 Console.WriteLine(Category.Name);
 foreach (var Product in Category.Products)
 {
 Console.WriteLine(Product.ProductID);
 }
 }

Generated SQL Query will be:

SELECT [Project1].[CatID] AS [CatID],
 [Project1].[Name] AS [Name],
 [Project1].[CreatedDate] AS [CreatedDate],
 [Project1].[C1] AS [C1],
 [Project1].[ProductID] AS [ProductID],
 [Project1].[Name1] AS [Name1],
 [Project1].[UnitPrice] AS [UnitPrice],
 [Project1].[CatID1] AS [CatID1],
 [Project1].[EntryDate] AS [EntryDate],
 [Project1].[ExpiryDate] AS [ExpiryDate]
 FROM (SELECT
 [Limit1].[CatID] AS [CatID],
 [Limit1].[Name] AS [Name],
 [Limit1].[CreatedDate] AS [CreatedDate],
 [Extent2].[ProductID] AS [ProductID],
 [Extent2].[Name] AS [Name1],
 [Extent2].[UnitPrice] AS [UnitPrice],
 [Extent2].[CatID] AS [CatID1],
 [Extent2].[EntryDate] AS [EntryDate],
 [Extent2].[ExpiryDate] AS [ExpiryDate],
 CASE WHEN ([Extent2].[ProductID] IS NULL) THEN CAST(NULL AS int)
ELSE 1 END AS [C1]
FROM (SELECT TOP (3) [c].[CatID] AS [CatID], [c].[Name] AS [Name], [c].[CreatedDate] AS [CreatedDate]
 FROM [dbo].[Category] AS [c] )
AS [Limit1]
 LEFT OUTER JOIN [dbo].[Product] AS [Extent2]
ON [Limit1].[CatID] = [Extent2].[CatID]) AS [Project1]
 ORDER BY [Project1].[CatID] ASC, [Project1].[C1] ASC

In above example, you have only one SQL queries which means calling the database only one time, for the Categories and the Products associated to the Categories. In this way, child entity is populated with parent entity.

I hope you will enjoy the tips while programming with LINQ and Entity Framework. I would like to have feedback from my blog readers. Your valuable feedback, question, or comments about this article are always welcome.
Continue Reading →

Topics

ADO .Net (2) Ajax (1) Angular Js (17) Angular2 (24) ASP .Net (14) Azure (1) Breeze.js (1) C# (49) CloudComputing (1) CMS (1) CSS (2) Design_Pattern (3) DI (3) Dotnet (21) Entity Framework (3) ExpressJS (4) Html (3) IIS (1) Javascript (6) Jquery (9) Lamda (3) Linq (11) Mongodb (1) MVC (48) NodeJS (7) RDLC (1) Report (1) Sql Server (29) SSIS (3) SSRS (2) UI (1) WCF (12) Web Api (10) Web Service (1) XMl (1)