Author: Akhil Mittal

Akhil Mittal is a Microsoft MVP(Most Valuable Professional), C# Corner MVP, Codeproject MVP, a blogger, author and likes to write/read technical articles. Akhil has an experience of around 11 years in developing, designing, architecting enterprises level applications primarily in Microsoft Technologies. Akhil enjoys working on technologies like MVC, Web API, Entity Framework, Angular, C# and BlockChain. Akhil is an MCP( Microsoft Certified Professional) in Web Applications (MCTS-70-528, MCTS-70-515) and .Net Framework 2.0 (MCTS-70-536). Visit Akhil Mittal’s personal blog CodeTeddy (https://codeteddy.com) for some good and informative articles.

Use the ENUM object to manipulate Enumerated Values

Enums are a tremendously easy way to make your code understandable. In the bad old days, when working on someone else’s program I’d be forced to decode code like this:

Dim cust As New Customer
cust.Type = 0

With an Enum, everything is more obvious:

Dim cust As New Customer
cust.Type = CustomerTypes.Deadbeat

What takes Enums to the next level are the static methods built into the Enum class. For instance, if I want to turn an Enum into an array of strings, I can use the Enum class’s GetNames method:

Dim cTypes As String() = [Enum].GetNames(GetType(CustomerTypes))

Because of the way Visual Basic handles names, Enum has to be enclosed in brackets to prevent syntax errors. C# doesn’t require those brackets:

string[] cTypes = Enum.GetNames(typeof(CustomerTypes));

I can then bind the output from GetNames to any listing control to get a list of the names in the Enum displayed in my user interface:

MyListBox.ItemsSource = Enum.GetNames(typeof(CustomerTypes));

GetNames shows the basic structure of the Enum class’s static methods: the first parameter to any method is always the Type of the Enum you want to work with. For instance, if you have code in a Web Service that’s passed the value of an Enum, you can convert that value into the name of the corresponding Enum entry using the Enum class’s GetName method. As before, the first parameter is the type of the Enum; the second parameter is the value you’re looking up:

Dim inputValue As Integer = 1
Me.MyTextBox.Text = [Enum].GetName(GetType(CustomerTypes), inputValue)

Parse goes one better and converts a string containing one of the names in an Enum into the Enum item itself. This code, for instance, sets the Customer object’s Type property to the appropriate Enum item based on a string value:

Dim custTypeString As String = "DeadBeat"
cust.Type = [Enum].Parse(
GetType(CustomerTypes), custTypeString);

Visual Basic doesn’t require the explicit cast to use Parse:

string custTypeString = "DeadBeat";
cust.Type = (CustomerTypes) Enum.Parse(
typeof(CustomerTypes), custTypeString);

If the string value you’re passing to Parse isn’t an item in the Enum, the Parse method throws an exception. To avoid that, you can use the Enum’s TryParse method which, while it still won’t do the conversion, won’t throw an exception either. An even better answer is to use the Enum’s IsDefined method to see if the item exists before trying to retrieve it:

if (Enum.IsDefined(typeof(CustomersType), custTypeString))
{
Customers ctype = (CustomersType) Enum.Parse(
typeof(CustomersType), custTypeString);
}
else
{
ErrorLabel.Text = "Not a valid customer type.";
}

(Taken from a blog.)

Features Added in Different Version of .Net Framework

.Net Framework 1.0 – This is the first version of .Net Framework that was released by Microsoft.

.Net Framework 1.1 – This is the 2nd major release of .Net Framework release by Microsoft. In this release it supports mobile ASP.Net controls, ODBC and Oracle Database. It also provides support for Internet Protocol version 6(I0v6).

.Net Framework 2.0 – It is part of Visual Studio 2005 and Microsoft SQL Server 2005. .Net Framework 2. Was the latest version of .Net Framework that has support Windows 2000.Net Framework 2.0 has many changes and enhancements as compared to ,Net Framework 1.1. It has a number of application programming interface changes. It contains many new personalization features for ASP.Net, for example, support for themes, skins, and web parts.

.Net Framework 3.0 – It uses the CLR version of 2.0. It contains a set of managed code APIs that form an integral part of Windows Vista and Windows Server 2008. .Net Framework 3.0 uses the same version of CLR that was incorporated with .Net Framework 2.0. It includes some new features as follows:

Windows Presentation Foundation
Windows Communication Foundation
Windows Workflow Foundation
Windows CardSpace

·.Net Framework 3.5 – .Net Framework 3.5 also uses the CLR version 2.0. In this release it supports LINQ, extension methods, lambda expression, anonymous types and built in Ajax support.

·.Net Framework 4.0 – In this release it supports PLINQ and Task Parallel Library. It supports Code Contracts and provides new types to work with arbitrary-precision arithmetic.

ASP.Net Grid View Sorting using jQuery

Download Source Code

The Article explains how to implement Sorting in Asp.Net Grid View using jQuery,

Just open the solution, and you’ll get to see the js file used to perform sorting on the GridView we have in Asp.Net aspx page.

The sorting is done on the basis of css class names provided in Style.css.

Just run the solution, and you’ll get to see that grid is sorted on the basis of string, date and numbers as well.

You can implement and extend this solution in your existing/new website.

Happy Coding J.

CRUD Operations using AutoMapper in C# MVC Application

Download Source Code

Introduction:

In our article series of Learning MVC, we learnt a lot about MVC, about various techniques to communicate to database in MVC applications, and few internal concepts too.

When we indulge into realtime programming environment, we face not only one but many type of challenges in the code.My this article explains a new concept Auto Mapper in MVC application to overcome one of the major challenge we face while communicating with data entities and binding them to our model.

Challenge:

Sometimes while interacting with real time(database) entities and binding our model to them, we end up in a situation like,

var dbContext = new MyDBDataContext();

var userDetails = dbContext.Users.FirstOrDefault(userId => userId.UserId == id);

var user = newLearningMVC.Models.User();

if (userDetails != null)

{

user.UserId = userDetails.UserId;

user.FirstName = userDetails.FirstName;

user.LastName = userDetails.LastName;

user.Address = userDetails.Address;

user.PhoneNo = userDetails.PhoneNo;

user.EMail = userDetails.EMail;

user.Company = userDetails.Company;

user.Designation = userDetails.Designation;

}

return View(user);

The above mentioned code is not very hard to understand ,In the above code, an instance var dbContext = new MyDBDataContext(); is created from a LinqTOSql Context class, there after user details from a Users specific table have been fetched and stored in var userDetails variable.We had an existing model named User(LearningMVC.Models.User()), that has similar properties as that of Users class generated from database, now we initialize properties of instance of our model from properties of instance of User class from database, so that we can populate our View in a MVC application.

We see here there are 8 properties that are similar to each other but each set lies in separate class, one in Model, and one in Users class.And what we do is one by one we bind these properties to our model and pass it to View.Now problem is what if we have 100 column records coming from database, and also our model have same no. of properties, and the code has to be repeated 6-7 times at different scenarios, now do we still follow such strategy of binding each property from db to model, trust me the code will be 100 pages large, and will be charging 5 times the effort just to bind the model from domain entities.

To overcome this tedious situation AutoMapper is introduced.It not only reduces the effort, but also limits the execution time that has been taken by such a large no. of lines to execute.

Auto Mapper:

AutoMapper is a open source provided in GitHub.

As per the AutoMapper CodePlex web page “AutoMapper is an object-object mapper. Object-object mapping works by transforming an input object of one type into an output object of a different type. What makes AutoMapper interesting is that it provides some interesting conventions to take the dirty work out of figuring out how to map type A to type B. As long as type B follows AutoMapper’s established conventions, almost zero configuration is needed to map two types.” therefore, it provides the solution for our mapping issue.

Install AutoMapper:

Firstly install the NuGet Package Manager in your Visual Studio IDE. Once done,go to

Tools -> Library Packet Manager -> Packet manager Console

Then in the console window opened at bottom of Visual Studio, type:

PM> Install-Package AutoMapper

Press Enter, this will install AutoMapper and when next time you open MVC application in Visual Studio , it will automatically add dll reference to project.

AutoMapper in Action:

Lets Create an MVC application first, you can create an MVC application, and connect it with database using LINQ to SQl following my article http://www.codeproject.com/Articles/620197/Learning-MVC-Part-2-Creating-MVC-Application-and-P

I have also attached the code of Existing MVC application used without AutoMapper.

Now let’s evaluate all the Controller Actions one by one and convert the code using AutoMapper.

Step1: Create database for existing application, the databse script is attached with the source code,

Open Existing MVC Application in Visual Studio,

See that AutoMapper is referenced in project, now use that namespace in MyController,as,

Step2: Index Action:

In the very first Action of our controller MyController(Can be found under Controllers folder), Index Action, we see the code,

public ActionResultIndex()

{

var dbContext = new MyDBDataContext();

var userList = fromuser in dbContext.Users select user;

var users = new List<LearningMVC.Models.User>();

if (userList.Any())

{

foreach (varuser in userList)

{

users.Add(new LearningMVC.Models.User()

{

UserId = user.UserId,

Address = user.Address,

Company = user.Company,

FirstName = user.FirstName,

LastName = user.LastName,

Designation = user.Designation,

EMail = user.EMail,

PhoneNo = user.PhoneNo

});

}

return View(users);

}

Now where will AutoMapper fit in here, you know that, it will be used to replace the property mapping done one by one in the code, therefore,

Just at the first line of code, define a AutoMap,

To create the default mapping, call the Mapper.CreateMap() with proper types. In this case, T1 will be LearningMVC.Userand T2 will be LearningMVC.Models.User

Mapper.CreateMap<LearningMVC.User, LearningMVC.Models.User>();

LearningMVC.User -> DTO Object Class

LearningMVC.Models.User -> Model Class to bind the View

So, here we define a mapping between, DTO and Model class with the help of AutoMapper class.

Now inside foreach loop, replace the whole code by,

LearningMVC.Models.UseruserModel = Mapper.Map<LearningMVC.User, LearningMVC.Models.User>(user);

users.Add(userModel);

Finally call the Mapper.Map(obj1) to get the mapped object of T2.

So, our final Action code,

public ActionResultIndex()

{

Mapper.CreateMap<LearningMVC.User, LearningMVC.Models.User>();

var dbContext = new MyDBDataContext();

var userList = fromuser in dbContext.Users select user;

var users = new List<LearningMVC.Models.User>();

if (userList.Any())

{

foreach (varuser in userList)

{

LearningMVC.Models.User userModel = Mapper.Map<LearningMVC.User, LearningMVC.Models.User>(user);

users.Add(userModel);

}

return View(users);

}

We see now, we escaped that boring work of matching properties one by one.Now run the application, and you’ll see the application running as before.

Step 3: Details Action:

Existing Code

public ActionResultDetails(int? id)

{

var dbContext = new MyDBDataContext();

var userDetails = dbContext.Users.FirstOrDefault(userId => userId.UserId == id);

var user = newLearningMVC.Models.User();

if (userDetails != null)

{

user.UserId = userDetails.UserId;

user.FirstName = userDetails.FirstName;

user.LastName = userDetails.LastName;

user.Address = userDetails.Address;

user.PhoneNo = userDetails.PhoneNo;

user.EMail = userDetails.EMail;

user.Company = userDetails.Company;

user.Designation = userDetails.Designation;

}

return View(user);

}

New Code with AutoMapper

public ActionResultDetails(int? id)

{

var dbContext = new MyDBDataContext();

Mapper.CreateMap<LearningMVC.User, LearningMVC.Models.User>();

var userDetails = dbContext.Users.FirstOrDefault(userId => userId.UserId == id);

LearningMVC.Models.User user = Mapper.Map<LearningMVC.User, LearningMVC.Models.User>(userDetails);

return View(user);

}

Step4: Create Action (POST)

Existing Code

[HttpPost]

public ActionResultCreate(LearningMVC.Models.User userDetails)

{

try

{

var dbContext = newMyDBDataContext();

var user = newUser();

if (userDetails != null)

{

user.UserId = userDetails.UserId;

user.FirstName = userDetails.FirstName;

user.LastName = userDetails.LastName;

user.Address = userDetails.Address;

user.PhoneNo = userDetails.PhoneNo;

user.EMail = userDetails.EMail;

user.Company = userDetails.Company;

user.Designation = userDetails.Designation;

}

dbContext.Users.InsertOnSubmit(user);

dbContext.SubmitChanges();

return RedirectToAction(“Index”);

}

catch

{

return View();

}

New Code with AutoMapper

[HttpPost]

public ActionResultCreate(LearningMVC.Models.User userDetails)

{

try

{

Mapper.CreateMap<LearningMVC.Models.User, LearningMVC.User>();

var dbContext = newMyDBDataContext();

varuser = Mapper.Map<LearningMVC.Models.User, LearningMVC.User>(userDetails);

dbContext.Users.InsertOnSubmit(user);

dbContext.SubmitChanges();

return RedirectToAction(“Index”);

}

catch

{

return View();

}

Note that, in here we interchanged the mapping, because now we had to read from Model and bind to our DTO fror Create Action, so just interchange the mapping, and run the application,Now our T1 is Model and T2 is DTO.

Step5: Edit Action:

Existing Code

public ActionResultEdit(int? id)

{

var dbContext = new MyDBDataContext();

var userDetails = dbContext.Users.FirstOrDefault(userId => userId.UserId == id);

var user = newLearningMVC.Models.User();

if (userDetails != null)

{

user.UserId = userDetails.UserId;

user.FirstName = userDetails.FirstName;

user.LastName = userDetails.LastName;

user.Address = userDetails.Address;

user.PhoneNo = userDetails.PhoneNo;

user.EMail = userDetails.EMail;

user.Company = userDetails.Company;

user.Designation = userDetails.Designation;

}

return View(user);

}

New Code with AutoMapper

public ActionResultEdit(int? id)

{

Mapper.CreateMap<LearningMVC.User, LearningMVC.Models.User>();

var dbContext = new MyDBDataContext();

var userDetails = dbContext.Users.FirstOrDefault(userId => userId.UserId == id);

var user = Mapper.Map<LearningMVC.User, LearningMVC.Models.User>(userDetails)

return View(user);

}

Step6: Delete Action:

Existing Code

public ActionResultDelete(int? id)

{

var dbContext = new MyDBDataContext();

var user = newLearningMVC.Models.User();

var userDetails = dbContext.Users.FirstOrDefault(userId => userId.UserId == id);

if (userDetails != null)

{

user.FirstName = userDetails.FirstName;

user.LastName = userDetails.LastName;

user.Address = userDetails.Address;

user.PhoneNo = userDetails.PhoneNo;

user.EMail = userDetails.EMail;

user.Company = userDetails.Company;

user.Designation = userDetails.Designation;

}

returnView(user);

}

New Code using AutoMapper

public ActionResultDelete(int? id)

{

var dbContext = new MyDBDataContext();

Mapper.CreateMap<LearningMVC.User, LearningMVC.Models.User>();

var userDetails = dbContext.Users.FirstOrDefault(userId => userId.UserId == id);

var user = Mapper.Map<LearningMVC.User, LearningMVC.Models.User>(userDetails);

return View(user);

}

ForMember() and MapFrom() in AutoMapper:

The two important functions in AutoMapper play an important role in object mapping, Suppose our model/viewmodel class have a property as FullName, and from the DTO we want to add the FirstName and Last Name of the user to make it a full name nad bind it to model,to overcome these kind of scenarios ForMember() and MapFrom() come in action,See below code,

Mapper.CreateMap<LearningMVC.User, LearningMVC.Models.User>().ForMember(emp => emp.Fullname,

map => map.MapFrom(p => p.FirstName + ” “+ p.LastName));

Here we are saying that ForMember FullName in our model class, map properties from FirstName and LastName of User DTO.

The code is itself self explanatory.

This kind of mapping is also called Custom Mapping.

Conclusion:

In this article we learnt how to do custom mapping and entity to entity mapping with the help of AutoMapper. Since this was just a glimpse of the concept there is lot more to explore in this topic in detail.

I have skipped the POST methods for Edit and Delete, this will be a kind of homework for you. Once you completely follow and understand, you can easily complete those two pending Actions as well.Let me see the source code J as well.

Other Series

My other series of articles:

For more technical articles you can reach out to my personal blog CodeTeddy.

ASP.Net MVC Interview Questions and Answers

Introduction:

My this article on Interview Questions and Answers of MVC basically covers most of the MVC 2, MVC3 and MVC4 topics that are more likely to be asked in job interviews/tests/exams.

The sole purpose of this article is to sum up important questions and answers that can be used by developers to brush-up all about MVC before they take any interview of the same kind.

What is MVC?

MVC is a framework pattern that splits an application’s implementation logic into

three component roles: models, views, and controllers.

Model: The business entity on which the overall application operates. Many applications use a persistent storage mechanism (such as a database) to store data. MVC does not specifically mention the data access layer because it is understood to be encapsulated by the Model.
View: The user interface that renders the Model into a form of interaction.
Controller: Handles a request from a View and updates the Model that results in a change of the Model’s state.

To implement MVC in .NET we need mainly three classes (View, Controller and the Model).

Explain MVC Architecture?

The architecture is self explanatory. The browser (as usual) sends a request to IIS, IIS searches for the route defined in MVC application and passes the request to the controller as per route, the controller communicates with the model and passes the populated model (entity) to View (front end), Views are populated with model properties, and are rendered on the browser, passing the response to browser through IIS via controllers which invoked the particular View.

What are the new features of MVC2?

ASP.NET MVC 2 was released in March 2010. Its main features are:

Introduction of UI helpers with automatic scaffolding with customizable templates.
Attribute-based model validation on both client and server.
Strongly typed HTML helpers.
Improved Visual Studio tooling
There were also lots of API enhancements and “pro” features, based on feedback from developers building a variety of applications on ASP.NET MVC 1, such as:

Support for partitioning large applications into areas.
Asynchronous controllers support.
Support for rendering subsections of a page/site using Html.RenderAction.
Lots of new helper functions, utilities, and API enhancements

What are the new features of MVC3?

ASP.NET MVC 3 shipped just 10 months after MVC 2 in Jan 2011.Some of the top features in MVC 3 included:

The Razor view engine.
Support for .NET 4 Data Annotations.
Improved model validation
Greater control and flexibility with support for dependency resolution and global action filters.
Better JavaScript support with unobtrusive JavaScript, jQuery Validation, and JSON binding.
Use of NuGet to deliver software and manage dependencies throughout the platform.

What are the new features of MVC4?

Following are the top features of MVC4:

ASP.NET Web API.
Enhancements to default project templates.
Mobile project template using jQuery Mobile.
Display Modes.
Task support for Asynchronous Controllers.
Bundling and minification.

Explain “page lifecycle” of an ASP.NET MVC?

Following process are performed by ASP.Net MVC page:

App initialization
Routing
Instantiate and execute controller
Locate and invoke controller action
Instantiate and render view

Advantages of MVC Framework?

Provides a clean separation of concerns between UI (Presentation layer), model (Transfer objects/Domain Objects/Entities) and Business Logic (Controller).
Easy to UNIT Test.
Improved reusability of views/model. One can have multiple views which can point tosame model and vice versa.
Improved structuring of the code.

What do you mean by Separation of Concerns?

As per Wikipedia ‘the process of breaking a computer program into distinct features that overlap in functionality as little as possible’. MVC design pattern aims to separate content from presentation and data-processing from content.

Where do we see Separation of Concerns in MVC?

Between the data-processing (Model) and the rest of the application.

When we talk about Views and Controllers, their ownership itself explains separation. The views are just the presentation form of an application, it does not have to know specifically about the requests coming from controller. The Model is independent of View and Controllers, it only holds business entities that can be passed to any View by the controller as required for exposing them to the end user. The controller is independent of Views and Models, its sole purpose is to handle requests and pass it on as per the routes defined and as per the need of rendering views. Thus our business entities (model), business logic (controllers) and presentation logic (views) lie in logical/physical layers independent of each other.

What is Razor View Engine?

Razor is the first major update to render HTML in MVC3. Razor was designed specifically as a view engine syntax. It has one main focus: code–focused templating for HTML generation. Here’s how that same markup would be generated using Razor:

@model MvcMusicStore.Models.Genre

@{ViewBag.Title = “Browse Albums”;}

<h3><em>@Model.Name</em> Albums</h3>

@foreach (var album in Model.Albums)

{

<li>

<span>@album.Title</span>

</a>

</li>

}

</ul>

</div>

The Razor syntax is easier to type, and easier to read. Razor doesn’t have the XML-like heavy syntax.

of the Web Forms view engine.

What is Unobtrusive JavaScript?

Unobtrusive JavaScript is a general term that conveys a general philosophy, similar to the term

REST (Representational State Transfer). The high-level description is that unobtrusive JavaScript doesn’t intermix JavaScript code in your page markup. For example, rather than hooking in via event attributes like onclick and onsubmit, the unobtrusive JavaScript attaches to elements by their ID or class, often based on the presence of other attributes (such as HTML5 data- attributes).

It’s got semantic meaning, and all of it — the tag structure, element attributes, and so on — should have a precise meaning. Strewing JavaScript gunk across the page to facilitate interaction (I’m looking at you, __doPostBack!) harms the content of the document.

What is JSON Binding?

MVC 3 included JavaScript Object Notation (JSON) binding support via the new

JsonValueProviderFactory, enabling the action methods to accept and model-bind data in JSON format. This is especially useful in advanced Ajax scenarios like client templates and data binding that need to post data back to the server.

What is Dependency Resolution?

MVC 3 introduced a new concept called a dependency resolver, which greatly simplified the use of dependency injection in your applications. This made it easier to decouple application components, making them more configurable and easier to test.

Support was added for the following scenarios:

Controllers (registering and injecting controller factories, injecting controllers)
Views (registering and injecting view engines, injecting dependencies into view pages)
Action fi lters (locating and injecting fi lters)
Model binders (registering and injecting)
Model validation providers (registering and injecting)
Model metadata providers (registering and injecting)
Value providers (registering and injecting)

What are Display Modes in MVC4?

Display modes use a convention-based approach to allow selecting different views based on the browser making the request. The default view engine fi rst looks for views with names ending with .Mobile.cshtml when the browser’s user agent indicates a known mobile device. For example, if we have a generic view titled Index.cshtml and a mobile view titled Index.Mobile.cshtml, MVC 4 will automatically use the mobile view when viewed in a mobile browser.

Additionally, we can register your own custom device modes that will be based on your own custom criteria — all in just one code statement. For example, to register a WinPhone device mode that would serve views ending with .WinPhone.cshtml to Windows Phone devices, you’d use the following code in the Application_Start method of your Global.asax:

DisplayModeProvider.Instance.Modes.Insert(0, new DefaultDisplayMode(“WinPhone”)

{

ContextCondition = (context => context.GetOverriddenUserAgent().IndexOf

(“Windows Phone OS”, StringComparison.OrdinalIgnoreCase) >= 0)

});

What is AuthConfig.cs in MVC4?

AuthConfig.cs is used to configure security settings, including sites for OAuth login.

What is BundleConfig.cs in MVC4?

BundleConfig.cs in MVC4 is used to register bundles used by the bundling and minification

system. Several bundles are added by default, including jQuery, jQueryUI, jQuery validation, Modernizr, and default CSS references.

What is FilterConfig.cs in MVC4?

This is used to register global MVC filters. The only filter registered by default is the HandleErrorAttribute, but this is a great place to put other filter registrations.

What is RouteConfig.cs in MVC4?

RouteConfig.cs holds the granddaddy of the MVC config statements, Route configuration.

What is WebApiConfig.cs in MVC4?

Used to register Web API routes, as well as set any additional Web API configuration settings.

What’s new in adding controller in MVC4 application?

Previously(in MVC3 and MVC2), the Visual Studio Add Controller menu item only displayed when we right-clicked on the Controllers folder. However, the use of the Controllers folder was purely for organization. (MVC will recognize any class that implements the IController interface as a Controller, regardless of its location in your application.) The MVC 4 Visual Studio tooling has been modified to display the Add Controller menu item for any folder in your MVC project. This allows us to organize your controllers however you would like, perhaps separating them into logical groups or separating MVC and Web API controllers.

What are the software requirements of ASP.NET MVC4 application?

MVC 4 runs on the following Windows client operating systems:

Windows XP
Windows Vista
Windows 7
Windows 8

It runs on the following server operating systems:

Windows Server 2003
Windows Server 2008
Windows Server 2008 R2

MVC 4 development tooling is included with Visual Studio 2012 and can be installed on Visual

Studio 2010 SP1/Visual Web Developer 2010 Express SP1.

What are the various types of Application Templates used to create an MVC application?

The various templates are as follows,

1. The Internet Application template: This contains the beginnings of an MVC web

application — enough so that you can run the application immediately after creating it

and see a few pages. This template also includes some basic account management functions which run against the ASP.NET Membership .

2. The Intranet Application template: The Intranet Application template was added as part of

the ASP.NET MVC 3 Tools Update. It is similar to the Internet Application template,but the account management functions run against Windows accounts rather than the ASP.NET Membership system.

3. The Basic template: This template is pretty minimal. It still has the basic folders, CSS, and

MVC application infrastructure in place, but no more. Running an application created using

the Empty template just gives you an error message.

Why use Basic template? The Basic template is intended for experienced MVC developers

who want to set up and configure things exactly how they want them.

4.The Empty template: The Basic template used to be called the Empty template, but developers complained that it wasn’t quite empty enough. With MVC 4, the previous Empty

template was renamed Basic, and the new Empty template is about as empty as we can get.

It has the assemblies and basic folder structure in place, but that’s about it.

5. The Mobile Application template: The Mobile Application template is preconfigured with jQuery Mobile to jump-start creating a mobile only website. It includes mobile visual themes, a touch-optimized UI, and support for Ajax navigation.

6. The Web API template: ASP.NET Web API is a framework for creating HTTP services.

The Web API template is similar to the Internet Application template but is streamlined for Web API development. For instance, there is no user account management functionality, as Web API account management is often signify-cantly different from standard MVC account management. Web API functionality is also available in the other MVC project templates, and even in non-MVC project types.

What are the default Top level directories created when adding MVC4 application?

Default Top level Directories are:

DIRECTORY PURPOSE

/Controllers To put Controller classes that handle URL requests

/Models To put classes that represent and manipulate data and business objects

/Views To put UI template files that are responsible for rendering output like HTML.

/Scripts To put JavaScript library files and scripts (.js)

/Images To put images used in your site

/Content To put CSS and other site content, other than scripts and images

/Filters To put filter code.

/App_Data To store data files you want to read/write

/App_Start To put configuration code for features like Routing, Bundling, Web API.

What is namespace of asp.net mvc?

ASP.NET MVC namespaces as well as classes are located in assembly System.Web.Mvc.

Note: Some of the content has been taken from various books/articles.

What is System.Web.Mvc namespace?

This namespace contains classes and interfaces that support the MVC pattern for ASP.NET Web applications. This namespace includes classes that represent controllers, controller

factories, action results, views, partial views, and model binders.

What is System.Web.Mvc.Ajax namespace?

System.Web.Mvc.Ajax namespace contains classes that supports Ajax scripting in an ASP.NET MVC application. The namespace includes support for Ajax scripts and Ajax option settings as well.

What is System.Web.Mvc.Async namespace?

System.Web.Mvc.Async namespace contains classes and interfaces that support asynchronous actions in an ASP.NET MVC application.

What is System.Web.Mvc.Html namespace?

System.Web.Mvc.Html namespace contains classes that help render HTML controls in an MVC application. This namespace includes classes that support forms, input controls, links, partial views, and validation.

What is ViewData, ViewBag and TempData?

MVC provides us ViewData, ViewBag and TempData for passing data from controller, view and in next requests as well. ViewData and ViewBag are similar to some extent but TempData performs additional roles.

What are the roles and similarities between ViewData and ViewBag?

Maintains data when move from controller to view.
Passes data from controller to respective view.
Their value becomes null when any redirection occurs, because their role is to provide a way to communicate between controllers and views. It’s a communication mechanism within the server call.

What are the differences between ViewData and ViewBag?(taken from a blog)

ViewData is a dictionary of objects that is derived from ViewDataDictionary class and accessible using strings as keys.
ViewBag is a dynamic property that takes advantage of the new dynamic features in C# 4.0.
ViewData requires typecasting for complex data type and check for null values to avoid error.
ViewBag doesn’t require typecasting for complex data type.

NOTE Although there might not be a technical advantage to choosing one format over the other, there are some critical differences to be aware of between the two syntaxes.

One obvious difference is that ViewBag works only when the key being accessed is a valid C# identifier. For example, if you place a value in ViewData[“KeyWith Spaces”], you can’t access that value using ViewBag because the codewon’t compile.

Another key issue to be aware of is that dynamic values cannot be passed in as parameters to extension methods. The C# compiler must know the real type of every parameter at compile time in order for it to choose the correct extension method.

If any parameter is dynamic, compilation will fail. For example, this code will always fail: @Html.TextBox(“name”, ViewBag.Name). To work around this,either use ViewData[“Name”] or cast the value to a specifi c type: (string) ViewBag.Name.

What is TempData?

TempData is a dictionary derived from the TempDataDictionary class and stored in short lives session. It is a string key and object value.

It keep the information for the time of an HTTP Request. This means only from one page to another. It helps to maintain data when we move from one controller to another controller or from one action to other action. In other words, when we redirect Tempdata helps to maintain data between those redirects. It internally uses session variables. Temp data use during the current and subsequent request only means it is use when we are sure that next request will be redirecting to next view. It requires typecasting for complex data type and check for null values to avoid error. Generally it is used to store only one time messages like error messages, validation messages.

How can you define a dynamic property with the help of viewbag in ASP.NET MVC?

Assign a key name with syntax,

ViewBag.[Key]=[ Value] and value using equal to operator.

For example, you need to assign list of students to the dynamic Students property

of ViewBag.

List students = new List();

countries.Add(“Akhil”);

countries.Add(“Ekta”);

ViewBag.Students = students;

//Students is a dynamic property associated with ViewBag.

Note: Some of the content has been taken from various books/articles.

What is ViewModel(taken from stackoverflow)?

First Name:</b></td>

.TextBoxFor(x => x.FirstName, new { maxlength = “50”, size = “50” })

@Html.ValidationMessageFor(x => x.FirstName)

accepted

A view model represents data that you want to have displayed on your view/page.

Lets say that you have an Employee class that represents your employee domain model and it contains the following 4 properties:

public class Employee : IEntity

{

public int Id { get; set; } // Employee’s unique identifier

public string FirstName { get; set; } // Employee’s first name

public string LastName { get; set; } // Employee’s last name

public DateTime DateCreated { get; set; } // Date when employee was created

}

View models differ from domain models in that view models only contain the data (represented by properties) that you want to use on your view. For example, lets say that you want to add a new employee record, your view model might look like this:

public class CreateEmployeeViewModel

{

public string FirstName { get; set; }

public string LastName { get; set; }

}

As you can see it only contains 2 of the properties of the employee domain model. Why is this you may ask? Id might not be set from the view, it might be auto generated by the Employee table. AndDateCreated might also be set in the stored procedure or in the service layer of your application. So Id and DateCreated is not need in the view model.

When loading the view/page, the create action method in your employee controller will create an instance of this view model, populate any fields if required, and then pass this view model to the view:

public class EmployeeController : Controller

{

private readonly IEmployeeService employeeService;

public EmployeeController(IEmployeeService employeeService)

{

this.employeeService = employeeService;

}

public ActionResult Create()

{

CreateEmployeeViewModel viewModel = new CreateEmployeeViewModel();

return View(viewModel);

}

public ActionResult Create(CreateEmployeeViewModel viewModel)

{

// Do what ever needs to be done before adding the employee to the database

}

Your view might look like this (assuming you are using ASP.NET MVC3 and razor):

@model MyProject.Web.ViewModels.ProductCreateViewModel

@Html

Last Name:</b></td>

@Html.TextBoxFor(x => x.LastName, new { maxlength = “50”, size = “50” })

@Html.ValidationMessageFor(x => x.LastName)

Validation would thus be done only on FirstName and LastName. Using Fluent Validation you might have validation like this:

public class CreateEmployeeViewModelValidator : AbstractValidator<CreateEmployeeViewModel>

{

public CreateEmployeeViewModelValidator()

{

RuleFor(x => x.FirstName)

.NotEmpty()

.WithMessage(“First name required”)

.Length(1, 50)

.WithMessage(“First name must not be greater than 50 characters”);

RuleFor(x => x.LastName)

.NotEmpty()

.WithMessage(“Last name required”)

.Length(1, 50)

.WithMessage(“Last name must not be greater than 50 characters”);

}

The key thing to remember is that the view model only represents the data that you want use. You can imagine all the uneccessary code and validation if you have a domain model with 30 properties and you only want to update a single value. Given this scenario you would only have this one value/property in the view model and not the whole domain object.

How do you check for AJAX request with C# in MVC.NET?

The solution is independed of MVC.NET framework and is global across server side

technologies. Most modern AJAX applications utilize XmlHTTPRequest to send

async request to the server. Such requests will have distinct request header:

X-Requested-With = XMLHTTPREQUEST

MVC.NET provides helper function to check for ajax requests which internally inspects

X-Requested-With request header to set IsAjax flag.

What are Scaffold template?

These templates use the Visual Studio T4 templating system to generate a view based on the model type selected. Scaffolding in ASP.NET MVC can generate the boilerplate code we need for create, read, update,and delete (CRUD) functionality in an application. The scaffolding templates can examine the type definition for, and then generate a controller and the controller’s associated views. The scaffolding knows how to name controllers, how to name views, what code needs to go in each component, and where to place all these pieces in the project for the application to work.

What are the types of Scaffolding Templates?

Various types are as follows,

SCAFFOLD DESCRIPTION

Empty Creates empty view. Only the model type is specified using the model syntax.

Create Creates a view with a form for creating new instances of the model.

Generates a label and input field for each property of the model type.

Delete Creates a view with a form for deleting existing instances of the model.

Displays a label and the current value for each property of the model.

Details Creates a view that displays a label and the value for each property of the

model type.

Edit Creates a view with a form for editing existing instances of the model.

Generates a label and input fi eld for each property of the model type.

List Creates a view with a table of model instances. Generates a column

for each property of the model type. Make sure to pass an IEnumerable to this view from your action method.

The view also contains links to actions for performing the create/edit/delete operations.

Show an example of difference in syntax in Razor and WebForm View?

Razor @model.Message

Web Forms

Code expressions in Razor are always HTML encoded. This Web Forms syntax also automatically HTML encodes the value.

What are Code Blocks in Views?

Unlike code expressions, which are evaluated and outputted to the response, blocks of code are simply sections of code that are executed. They are useful for declaring variables that we may need to use later.

Razor

int x = 123;

string y = ˝because.˝;

}

Web Forms

int x = 123;

string y = “because.”;

What is HelperPage.IsAjax Property?

HelperPage.IsAjax gets a value that indicates whether Ajax is being used during the request of the Web page.

Namespace: System.Web.WebPages

Assembly: System.Web.WebPages.dll

However, same can be achieved by checking requests header directly:

Request[“X-Requested-With”] == “XmlHttpRequest”.

Explain combining text and markup in Views with the help of an example?

This example shows what intermixing text and markup looks like using Razor as compared to Web Forms:

Razor

@foreach (var item in items) {

Item @item.Name.

}

Web Forms

Item .

Explain Repository Pattern in ASP.NET MVC?

In simple terms, a repository basically works as a mediator between our business logic layer and our data access layer of the application. Sometimes, it would be troublesome to expose the data access mechanism directly to business logic layer, it may result in redundant code for accessing data for similar entities or it may result in a code that is hard to test or understand. To overcome these kinds of issues, and to write an Interface driven and test driven code to access data, we use Repository Pattern. The repository makes queries to the data source for the data, thereafter maps the data from the data source to a business entity/domain object, finally and persists the changes in the business entity to the data source. According to MSDN, a repository separates the business logic from the interactions with the underlying data source or Web service. The separation between the data and business tiers has three benefits:

It centralizes the data logic or Web service access logic.
It provides a substitution point for the unit tests.
It provides a flexible architecture that can be adapted as the overall design of the application evolves.

In Repository, we write our whole business logic of CRUD operations with the help of Entity Framework classes, that will not only result in meaningful test driven code but will also reduce our controller code of accessing data.

How can you call a javascript function/method on the change of Dropdown List in MVC?

Create a java-script method:

function selectedIndexChanged() {

}

Invoke the method:

x.SelectedProduct,

new SelectList(Model.Users, “Value”, “Text”),

“Please Select a User”, new { id = “ddlUsers”,

onchange=”selectedIndexChanged()” })%>

Explain Routing in MVC?

A route is a URL pattern that is mapped to a handler. The handler can be a physical

file, such as an .aspx file in a Web Forms application. Routing module is responsible for mapping incoming browser requests to particular MVC controller actions.

Routing within the ASP.NET MVC framework serves two main purposes:

It matches incoming requests that would not otherwise match a file on the file system and maps the requests to a controller action.
It constructs outgoing URLs that correspond to controller actions.

How route table is created in ASP.NET MVC?

When an MVC application first starts, the Application_Start() method in global.asax is called. This method, calls the RegisterRoutes() method. The RegisterRoutes() method creates the route table for MVC application.

What are Layouts in ASP.NET MVC Razor?

Layouts in Razor help maintain a consistent look and feel across multiple views within our application.As compared to Web Forms Web Forms, layouts serve the same purpose as master pages, but offer both a simpler syntax and greater flexibility.

We can use a layout to define a common template for your site (or just part of it). This template contains one or more placeholders that the other views in your application provide content for. In some ways, it’s like an abstract base class for your views.

e.g. declared at the top of view as,

Layout = “~/Views/Shared/SiteLayout.cshtml”;

}

What is ViewStart?

For group of views that all use the same layout, this can get a bit redundant and harder to maintain.

The _ViewStart.cshtml page can be used to remove this redundancy. The code within this file

is executed before the code in any view placed in the same directory. This fi le is also recursively applied to any view within a subdirectory.

When we create a default ASP.NET MVC project, we find there is already a _ViewStart

.cshtml fi le in the Views directory. It specifi es a default layout:

Layout = “~/Views/Shared/_Layout.cshtml”;

}

Because this code runs before any view, a view can override the Layout property and choose a different one. If a set of views shares common settings, the _ViewStart.cshtml file is a useful place to consolidate these common view settings. If any view needs to override any of the common settings, the view can set those values to another value.

Note: Some of the content has been taken from various books/articles.

What are HTML Helpers?

HTML helpers are methods we can invoke on the Html property of a view. We also have

access to URL helpers (via the Url property), and AJAX helpers (via the Ajax property). All

these helpers have the same goal: to make views easy to author. The URL helper is also available from within the controller.

Most of the helpers, particularly the HTML helpers, output HTML markup. For example, the

BeginForm helper is a helper we can use to build a robust form tag for our search

form, but without using lines and lines of code:

@using (Html.BeginForm(“Search”, “Home”, FormMethod.Get)) {

}

What is Html.ValidationSummary?

The ValidationSummary helper displays an unordered list of all validation errors in the ModelState dictionary. The Boolean parameter you are using (with a value of true) is telling the helper to exclude property-level errors. In other words, you are telling the summary to display only the errors in ModelState associated with the model itself, and exclude any errors associated with a specific model property. We will be displaying property-level errors separately.Assume you have the following code somewhere in the controller action rendering the edit view:

ModelState.AddModelError(“”, “This is all wrong!”);

ModelState.AddModelError(“Title”, “What a terrible name!”);

The first error is a model-level error, because you didn’t provide a key (or provided an empty key) to associate the error with a specifi c property. The second error you associated with the Title property, so in your view it will not display in the validation summary area (unless you remove the parameter to the helper method, or change the value to false). In this scenario, the helper renders the following HTML:

This is all wrong!

Other overloads of the ValidationSummary helper enable you to provide header text and set specific HTML attributes.

NOTE By convention, the ValidationSummary helper renders the CSS class validation-summary-errors along with any specifi c CSS classes you provide.The default MVC project template includes some styling to display these items in red, which you can change in styles.css.

What are Validation Annotations?

Data annotations are attributes you can find in System.ComponentModel.DataAnnotations

namespace.These attributes provide server-side validation, and the framework also supports client-side validation when you use one of the attributes on a model property. You can use four attributes in the DataAnnotations namespace to cover common validation scenarios,

Required, String Length, Regular Expression, Range.

What is Html.Partial?

The Partial helper renders a partial view into a string. Typically, a partial view contains reusable markup you want to render from inside multiple different views. Partial has four overloads:

public void Partial(string partialViewName);

public void Partial(string partialViewName, object model);

public void Partial(string partialViewName, ViewDataDictionary viewData);

public void Partial(string partialViewName, object model,

ViewDataDictionary viewData);

What is Html.RenderPartial?

The RenderPartial helper is similar to Partial, but RenderPartial writes directly to the response output stream instead of returning a string. For this reason, you must place RenderPartial inside a code block instead of a code expression. To illustrate, the following two lines of code render the same output to the output stream:

@{Html.RenderPartial(“AlbumDisplay “); }

@Html.Partial(“AlbumDisplay “)

If they are same then which one to use?

In general, you should prefer Partial to RenderPartial because Partial is more convenient (you don’t have to wrap the call in a code block with curly braces). However, RenderPartial may result in better performance because it writes directly to the response stream, although it would require a lot of use (either high site traffic or repeated calls in a loop) before the difference would be noticeable.

How do you return a partial view from controller?

return PartialView(options); //options could be Model or View name

What are different ways of returning a View?

There are different ways for returning/rendering a view in MVC Razor.E.g. return View(), return RedirectToAction(), return Redirect() and return RedirectToRoute().

Conclusion:

I hope we covered a lot of questions to brush-up. Since MVC is very vast now,I know we have missed a lot stuff too.The content in the question and answer form is also taken from few renowned books like Professional asp.net MVC4 from wrox, and few of the content is taken from myMVC articles posted earlier. My upcoming articles will provide interview questions for EntityFramework too.

View my asp.net article of the day- Code First Approach using Entity Framework 4.1, Inversion of Control, Unity Framework, Repository & Unit of Work Pattern and MVC3 Razor View

Best of Luck and Happy Coding J.

C# and ASP.Net Interview Question and Answers

What is the significance of Finalize method in .NET?

.NET Garbage collector does almost all clean up activity for your objects. But unmanaged

resources (ex: – Windows API created objects, File, Database connection objects, COM objects

etc) is outside the scope of .NET framework we have to explicitly clean our resources. For these

types of objects, .NET framework provides Object. Finalize method, which can be overridden and

clean up code for unmanaged resources can be put in this section?

Why is it preferred to not use finalize for clean up?

Problem with finalize is that garbage collection has to make two rounds in order to remove

objects which have finalize methods.

Below figure will make things clear regarding the two rounds of garbage collection rounds

performed for the objects having finalized methods.

Note:Few of the content is taken from various blogs/articles.

In this scenario there are three objects Object1, Object2, and Object3. Object2 has the finalize

method overridden and remaining objects do not have the finalize method overridden.

Now when garbage collector runs for the first time it searches for objects whose memory has to

free. He can see three objects but only cleans the memory for Object1 and Object3. Object2 it

pushes to the finalization queue.

Now garbage collector runs for the second time. He see’s there are no objects to be released and

then checks for the finalization queue and at this moment, it clears object2 from the memory.

So if you notice that object2 was released from memory in the second round and not first. That is

why the best practice is not to write clean up Non.NET resources in Finalize method rather use

the DISPOSE.

What is the use of DISPOSE method?

Dispose method belongs to ‘IDisposable’ interface. We had seen in the previous section how bad

it can be to override the finalize method for writing the cleaning of unmanaged resources. So if

any object wants to release its unmanaged code best is to implement I Disposable and override

the Dispose method of I Disposable interface. Now once your class has exposed the Dispose

method it is the responsibility of the client to call the Dispose method to do the cleanup.

How do I force the Dispose method to be called automatically, as

clients can forget to call Dispose method?

Call the Dispose method in Finalize method and in Dispose method suppress the finalize method

using GC.SuppressFinalize. Below is the sample code of the pattern. This is the best way we do

clean our unallocated resources and yes not to forget we do not get the hit of running the Garbage

collector twice.

public class CleanClass : IDisposable

{

public void Dispose()

{

GC.SuppressFinalize(this);

}

protected override void Finalize()

{

Dispose();

}

Note:Few of the content is taken from various blogs/articles.

What is an interface and what is an abstract class? Please, expand by examples of using both. Explain why.
Answers1:
In a interface class, all methods are abstract without implementation where as in an abstract class some methods we can define concrete. In interface, no accessibility modifiers are allowed. An abstract class may have accessibility modifiers. Interface and abstract class are basically a set of rules which u have to follow in case u r using them(inheriting them).

Answers2:
Abstract classes are closely related to interfaces. They are classes that cannot be instantiated, and are frequently either partially implemented, or not at all implemented. One key difference between abstract classes and interfaces is that a class may implement an unlimited number of interfaces, but may inherit from only one abstract (or any other kind of) class. A class that is derived from an abstract class may still implement interfaces. Abstract classes are useful when creating components because they allow you specify an invariant level of functionality in some methods, but leave the implementation of other methods until a specific implementation of that class is needed. They also version well, because if additional functionality is needed in derived classes, it can be added to the base class without breaking code.

Answers3:
Abstract Classes
An abstract class is the one that is not used to create objects. An abstract class is designed to act as a base class (to be inherited by other classes). Abstract class is a design concept in program development and provides a base upon which other classes are built. Abstract classes are similar to interfaces. After declaring an abstract class, it cannot be instantiated on it’s own, it must be inherited. Like interfaces, abstract classes can specify members that must be implemented in inheriting classes. Unlike interfaces, a class can inherit only one abstract class. Abstract classes can only specify members that should be implemented by all inheriting classes.

Answers4:
An interface looks like a class, but has no implementation. They’re great for putting together plug-n-play like architectures where components can be interchanged at will. Think Firefox Plug-in extension implementation. If you need to change your design, make it an interface. However, you may have abstract classes that provide some default behavior. Abstract classes are excellent candidates inside of application frameworks.

Answers5:
One additional key difference between interfaces and abstract classes (possibly the most important one) is that multiple interfaces can be implemented by a class, but only one abstract class can be inherited by any single class.
Some background on this: C++ supports multiple inheritance, but C# does not. Multiple inheritance in C++ has always be controversial, because the resolution of multiple inherited implementations of the same method from different base classes is hard to control and anticipate. C# decided to avoid this problem by allowing a class to implement multiple interfaces, which do not contain method implementations, but restricting a class to have at most a single parent class. Although this can result in redundant implementations of the same method when different classes implement the same interface, it is still an excellent compromise.
Another difference between interfaces and abstract classes is that an interface can be implemented by an abstract class, but no class, abstract or otherwise, can be inherited by an interface.

Answers6:
What is an Abstract class?
An abstract class is a special kind of class that cannot be instantiated. So the question is why we need a class that cannot be instantiated? An abstract class is only to be sub-classed (inherited from). In other words, it only allows other classes to inherit from it but cannot be instantiated. The advantage is that it enforces certain hierarchies for all the subclasses. In simple words, it is a kind of contract that forces all the subclasses to carry on the same hierarchies or standards.
What is an Interface?
An interface is not a class. It is an entity that is defined by the word Interface. An interface has no implementation; it only has the signature or in other words, just the definition of the methods without the body. As one of the similarities to Abstract class, it is a contract that is used to define hierarchies for all subclasses or it defines specific set of methods and their arguments. The main difference between them is that a class can implement more than one interface but can only inherit from one abstract class. Since C# doesn’t support multiple inheritance, interfaces are used to implement multiple inheritance.

How does output caching work in ASP.NET?
Output caching is a powerful technique that increases request/response throughput by caching the content generated from dynamic pages. Output caching is enabled by default, but output from any given response is not cached unless explicit action is taken to make the response cacheable.
To make a response eligible for output caching, it must have a valid expiration/validation policy and public cache visibility. This can be done using either the low-level OutputCache API or the high-level @ OutputCache directive. When output caching is enabled, an output cache entry is created on the first GET request to the page. Subsequent GET or HEAD requests are served from the output cache entry until the cached request expires.
The output cache also supports variations of cached GET or POST name/value pairs.
The output cache respects the expiration and validation policies for pages. If a page is in the output cache and has been marked with an expiration policy that indicates that the page expires 60 minutes from the time it is cached, the page is removed from the output cache after 60 minutes. If another request is received after that time, the page code is executed and the page can be cached again. This type of expiration policy is called absolute expiration – a page is valid until a certain time.

What is connection pooling and how do you make your application use it?
Opening database connection is a time consuming operation.
Connection pooling increases the performance of the applications by reusing the active database connections instead of create new connection for every request.
Connection pooling Behaviour is controlled by the connection string parameters.
Follwing the the 4 parameters that control most of the connection pooling behaviour.
1. Connect Timeout
2. Max Pool Size
3. Min Pool Size
4. Pooling

What are different methods of session maintenance in ASP.NET?
3 types:
In-process storage.
Session State Service.
Microsoft SQL Server.

In-Process Storage
The default location for session state storage is in the ASP.NET process itself.

Session State Service
As an alternative to using in-process storage for session state, ASP.NET provides the ASP.NET State Service. The State Service gives you an out-of-process alternative for storing session state that is not tied quite so closely to ASP. Net’s own process.

To use the State Service, you need to edit the sessionState element in your ASP.NET application’s web.config file:
You’ll also need to start the ASP.NET State Service on the computer that you specified in the stateConnectionString attribute. The .NET Framework installs this service, but by default it’s set to manual startup. If you’re going to depend on it for storing session state, you’ll want to change that to automatic startup by using the Services MMC plug-in in the Administrative Tools group.

If you make these changes, and then repeat the previous set of steps, you’ll see slightly different behavior: session state persists even if you recycle the ASP.NET process.

There are two main advantages to using the State Service. First, it is not running in the same process as ASP.NET, so a crash of ASP.NET will not destroy session information. Second, the stateConnectionString that’s used to locate the State Service includes the TCP/IP address of the service, which need not be running on the same computer as ASP.NET. This allows you to share state information across a web garden (multiple processors on the same computer) or even across a web farm (multiple servers running the application). With the default in-process storage, you can’t share state information between multiple instances of your application.

The major disadvantage of using the State Service is that it’s an external process, rather than part of ASP.NET. That means that reading and writing session state is slower than it would be if you kept the state in-process. And, of course, it’s one more process that you need to manage. As an example of the extra effort that this can entail, there is a bug in the initial release of the State Service that allows a determined attacker to crash the ASP.NET process remotely. If you’re using the State Service to store session state, you should install the patch from Microsoft Security Bulletin MS02-66, or install SP2 for the .NET Framework.

Microsoft SQL Server
The final choice for storing state information is to save it in a Microsoft SQL Server database. To use SQL Server for storing session state, you need to perform several setup steps:

Run the InstallSqlState.sql script on the Microsoft SQL Server where you intend to store session state. This script will create the necessary database and database objects. The .NET Framework installs this script in the same folder as its compilers and other tools–for example, C:\WINNT\Microsoft.NET\Framework\v1.0.3705 on a Windows 2000 computer with the 1.0 version of the Framework. Edit the sessionState element in the web.config file for your ASP.NET application as follows:

Supply the server name, user name, and password for a SQL Server account that has access to the session state database in the sqlConnectionString attribute.
Like the State Service, SQL Server lets you share session state among the processors in a web garden or the servers in a web farm. But you also get the additional benefit of persistent storage. Even if the computer hosting SQL Server crashes and is restarted, the session state information will still be present in the database, and will be available as soon as the database is running again. That’s because SQL Server, being an industrial-strength database, is designed to log its operations and protect your data at (almost) all costs. If you’re willing to invest in SQL Server clustering, you can keep the session state data available transparently to ASP.NET even if the primary SQL Server computer crashes.

Like the State Service, SQL Server is slower than keeping session state in process. You also need to pay additional licensing fees to use SQL Server for session state in a production application. And, of course, you need to worry about SQL Server-specific threats such as the “Slammer” worm.

What does the “EnableViewState” property do? Why would I want it on or off?
Enable ViewState turns on the automatic state management feature that enables server controls to re-populate their values on a round trip without requiring you to write any code. This feature is not free however, since the state of a control is passed to and from the server in a hidden form field. You should be aware of when ViewState is helping you and when it is not. For example, if you are binding a control to data on every round trip (as in the datagrid example in tip #4), then you do not need the control to maintain it’s view state, since you will wipe out any re-populated data in any case. ViewState is enabled for all server controls by default. To disable it, set the EnableViewState property of the control to false.

What is the difference between Server.Transfer and Response.Redirect?
Why would I choose one over the other? Server.Transfer() : client is shown as it is on the requesting page only, but the all the content is of the requested page. Data can be persist across the pages using Context.Item collection, which is one of the best way to transfer data from one page to another keeping the page state alive. Response.Dedirect() :client know the physical location (page name and query string as well). Context.Items loses the persistence when navigate to destination page. In earlier versions of IIS, if we wanted to send a user to a new Web page, the only option we had was Response.Redirect. While this method does accomplish our goal, it has several important drawbacks. The biggest problem is that this method causes each page to be treated as a separate transaction. Besides making it difficult to maintain your transactional integrity, Response.Redirect introduces some additional headaches. First, it prevents good encapsulation of code. Second, you lose access to all of the properties in the Request object. Sure, there are workarounds, but they’re difficult. Finally, Response.Redirect necessitates a round trip to the client, which, on high-volume sites, causes scalability problems. As you might suspect, Server.Transfer fixes all of these problems. It does this by performing the transfer on the server without requiring a roundtrip to the client.

Polymorphism, Method hiding and overriding :

One of the fundamental concepts of object oriented software development is polymorphism. The term polymorphism (from the Greek meaning “having multiple forms”) in OO is the characteristic of being able to assign a different meaning or usage to something in different contexts – specifically, to allow a variable to refer to more than one type of object.

Example Class Hierarchy

Let’s assume the following simple class hierarchy with classes A, B and C for the discussions in this text. A is the super- or base class, B is derived from A and C is derived from class B. In some of the easier examples, we will only refer to a part of this class hierarchy.

Inherited Methods

A method Foo() which is declared in the base class A and not redeclared in classes B or C is inherited in the two subclasses

    using System;
    namespace Polymorphism
    {
        class A
        {
            public void Foo() { Console.WriteLine(“A::Foo()“); }
        }

class B : A {}

        class Test
        {
            static void Main(string[] args)
            {
                A a = new A();
                a.Foo();  // output –> “A::Foo()”

                B b = new B();
                b.Foo();  // output –> “A::Foo()”
            }
        }
    }

The method Foo() can be overridden in classes B and C:

    using System;
    namespace Polymorphism
    {
        class A
        {
              public void Foo() { Console.WriteLine(“A::Foo()“); }
        }

        class B : A
        {
              public void Foo() { Console.WriteLine(“B::Foo()“); }
        }

        class Test
        {
            static void Main(string[] args)
            {
                A a;
                B b;

                a = new A();
                b = new B();
                a.Foo();  // output –> “A::Foo()”
                b.Foo();  // output –> “B::Foo()”

                a = new B();
                a.Foo();  // output –> “A::Foo()”
            }
        }
    }

There are two problems with this code.

o The output is not really what we, say from Java, expected. The method Foo() is a non-virtual method. C# requires the use of the keyword virtual in order for a method to actually be virtual. An example using virtual methods and polymorphism will be given in the next section.

o Although the code compiles and runs, the compiler produces a warning:

…\polymorphism.cs(11,15): warning CS0108: The keyword new is required on ‘Polymorphism.B.Foo()’ because it hides inherited member ‘Polymorphism.A.Foo()’

This issue will be discussed in section Hiding and Overriding Methods.

Note:Few of the content is taken from various blogs/articles.

Virtual and Overridden Methods

Only if a method is declared virtual, derived classes can override this method if they are explicitly declared to override the virtual base class method with the override keyword.

    using System;
    namespace Polymorphism
    {
        class A
        {
            public virtual void Foo() { Console.WriteLine(“A::Foo()“); }
        }

        class B : A
        {
            public override void Foo() { Console.WriteLine(“B::Foo()“); }
        }

        class Test
        {
            static void Main(string[] args)
            {
                A a;
                B b;

                a = new A();
                b = new B();
                a.Foo();  // output –> “A::Foo()”
                b.Foo();  // output –> “B::Foo()”

                a = new B();
                a.Foo();  // output –> “B::Foo()”
            }
        }
     }

Method Hiding

Why did the compiler in the second listing generate a warning? Because C# not only supports method overriding, but also method hiding. Simply put, if a method is not overriding the derived method, it is hiding it. A hiding method has to be declared using the new keyword. The correct class definition in the second listing is thus:

    using System;
    namespace Polymorphism
    {
        class A
        {
            public void Foo() { Console.WriteLine(“A::Foo()“); }
        }

        class B : A
        {
            public new void Foo() { Console.WriteLine(“B::Foo()“); }
        }

        class Test
        {
            static void Main(string[] args)
            {
                A a;
                B b;

                a = new A();
                b = new B();
                a.Foo();  // output –> “A::Foo()”
                b.Foo();  // output –> “B::Foo()”

                a = new B();
                a.Foo();  // output –> “A::Foo()”
            }
        }
    }

Combining Method Overriding and Hiding

Methods of a derived class can both be virtual and at the same time hide the derived method. In order to declare such a method, both keywords virtual and new have to be used in the method declaration:

            class A
            {
                public void Foo() {}
            }

            class B : A
            {
                public virtual new void Foo() {}
            }

A class C can now declare a method Foo() that either overrides or hides Foo() from class B:

            class C : B
            {
                public override void Foo() {}
                // or
                public new void Foo() {}
            }

Note:Few of the content is taken from various blogs/articles.

Conclusion

o C# is not Java.

o Only methods in base classes need not override or hide derived methods. All methods in derived classes require to be either defined as new or as override.

o Know what your doing and look out for compiler warnings.

Few of the references taken from ,

http://www.dotnetinterviewquestions.in/article_net-interview-questions-6th-edition-sixth-edition-by-shivprasad-koirala_144.html

.NET interview questions 6th edition (Sixth edition) – By Shivprasad Koirala

www.dotnetinterviewquestions.in

In this article we will explain .NET interview questions 6th edition (Sixth edition) – By Shivprasad Koirala.

I thank Shivprasad Koirala Sir for the wonderful contribution.

Code First Approach using Entity Framework 4.1, Inversion of Control, Unity Framework, Repository & Unit of Work Pattern and MVC3 Razor View

Download Source Code

Introduction :

In my previous article I discussed about developing a simple basic multilayered architecture for a .Net application.However there were few points that I skipped considering that the article was for beginners.When we talk about an application architecture there are certain points that need to be put into consideration before initiating,

Is the architecture loosely coupled?
Is it to be service based?
Where should the entities reside?
What should be Mode of Communication with the database?
Do it require design patterns? If yes,What patterns should be implemented?
Should it be based on Seperation of Concerns?

To answer these type of questions, .Net 4 has come up with a generic solution,making use of Entity Framework.

My effort in this article would be to put some light on building a generic multilayered architecture using Entity Framework 4.1 and MVC3 razor view engine.We’ll use inversion of control to resolve dependency of layers.The points to be covered in this article would be as follows,

Use of Seperation of Concerns,
Use of Code First approach,
POCO objects,
Repository Pattern,
Dependency Injection and Inversion of Control.

Architecture Overview:

I have created an architecture to explaing all the above mentioned points, and we’ll stick to this architecture till the end of article thus implementing practically our understanding.

I have created a very simple application to add student details in database, To edit it and to delete it,My first page shows list of all added student.

The arcitecture is service based, following are the components and pictorial representation (fig1) of it, we’ll discuss each component in detail,

CodeFirstData layer.
CodeFirstEntities layer.
CodeFirstServices layer.
MVC Portal layer.

Architecture components:

Let’s discuss each and every component of the defined architecture in detail,
1. CodeFirstData layer :
The data layer is the class library defining a layer which is responsible for interacting with database, contains context classes and a factory pattern implementation to interact with database.The layer contains the repository for each entity to map with database,thus making a complete ORM (Object Resource Model) solution.The class library references EntityFramework dll to implement the dbcontext classes.
1. CodeFirstEntities layer:
Entity layer acts as a model to MVC application,and also responsible for creation of DataBase objects when the dbset is first executed.It contains Entity classes in POCO form, having relations and data annotations(Rules/Constraints to be put on Database table/columns).

The properties of the class results in column name in database and name osf the class in Dtaabase table.Primary key is either defined by the property named Id or “Classname[Id]”,in our case “StudentId”,this is default protocol set by entityframework to keep in mind while creating entities.Since this application is codefirest,we need to create entities first.
1. CodeFirstServices layer:
The layer contains services which uses repositories to fetch data from database. The interaction between Services and Repositories is kept loosely coupled thus implementing Inversion of Control using Dependency Injection.Its constructor based dependency injection and do not allow service to make direct instance of our repositories.Service layer acts as an interface between controllers and repositories,passes request of controller to repositories.
1. MVCPortal layer:
MVCPortal layer is our UI layer, it contains Model/ViewModels,Views and Controllers.I am not going into details of MVC as its not our primary target,I assume that you already know how to create and run MVC application,Lets have a quick revision of MVC,
Model classea are responsible for holding up and manipulating data,we bind model/viewmodel classes to views to display model specific data.model classes are prepopulated by controllers to show data with the lehp of views.
Views holds up our UI templates, We have controller methods defined for every view, which populates View Design with data, and requests particular type of view to be rendered at user’s end as per requirement.
Web-based MVC frameworks map URLs to server code in a bit different fashion. Instead of mapping incoming URLs to html/aspx files, they instead map URLs to methods on classes. These classes are called “Controllers” and they are responsible for processing incoming HTTP requests, handling user input, retrieving and saving data, and determining the response to send back to the client (display HTML, download a file, redirect to a different URL, etc.).

The layer makes use of Dependency injection to achieve Inversion of Control for services, thus not allowing controllers to directly acces services instances,The IOC is acheived using global.asax file using UnityFramework library of Microsoft.

5. Dlls : I have created DLLs folder and given the output build path for every class library to that folder, for ease of access to Dll’s to add reference.Now each Dll will be created in the Dlls folder and we can access the desired Dll from the same folder. Also keep the EntityFramework,UnityConfiguration Dlls into it.

IOC and DI :

Dependency Injection is an important component in my application . All the services are required to be late bound with Model layer with Dependency Injection. In addition, the IoC container manages the lifetime of service objects. For example the Context object. I set lifetime type as PerThreadLifetimeManager in Unity configuration. This makes one and only one context object created in a single request and the different request has a different context object. Another thing I want to mention is ASP.NET MVC3 has its own way to provide Dependency Inject for controller via implementing DependencyResolver interface. The IoC container I used in the demo is Unity.

Container :

The “Container” or “IOC Container” is the main object that is used to create objects and inject dependencies into them. Whenever you want an object to be open to IoC, you have to use the container to create the instance using container.Resolve() method instead of the “new” keyword.

IService service = unityContainer.Resolve();

I have added following references to acheive the same,

Microsoft.Practices.Unity

Microsoft.Practices.Unity.Configuration

The code for IOC is implemented in global.asax file.

Step by Step Process to create the Application using EntityFramework Architecture :

Application Overview :

We’ll try to develop a simple studentDetails application with the help of discusses architecture,The application’s main module will be to Create a new student, Edit existing student,Delete existing student, and to show list of all students.Looking into a wider/generic perspective, the application performs CRUD operations on database with the help of EF .

Note that we’ll not create databse by our own,we just write classes and defing connection configuration of our database server in web.config file, and let EntityFramework do rest of the job of creating database, managing database and Mapping database with our entities.

Step1. Creating a solution and blank projects/seperating them logically/physically as layers :

Our first initiative is to prepare our initial level architecture there by creating solution and adding project files to it, We create a solution named CodeFirstEntities and add three class libraries to it thus defining our three layers which are Entity,Data and Service, the names of the class libraries which i chose are CodeFirstEntities,CodeFirstData and CodeFirstServices respectively.

Now add an MVC3 application to the solution called MvcPortal, that will act as a UI layer for our application. Refer fig2 for implementing the first step.

( fig2 )

Step 2. Creating Entities :

Add Student.cs class to CodeFirstEntities project , this class will contain the student details specific properties that will take the shape of database table and columns . The class makes use of DataAnnotation dll to put data annotations (rules/constraints) over the properties that will be reflected in database table.The constraints like max length and required parameter are provided as attributes over the properties of the class as shown in fig3 and fig4,

( fig3 )

( fig4)

The above entities is very simple POCO (Plain Old CLR Object) class and the entity Student is decorated with validation attributes in the System.ComponentModel.DataAnnotations namespace. Now we want to use these entities for defining model objects for the Entity Framework 4. Using the Code First approach of Entity Framework, we can first define the entities by simply writing POCO classes without any coupling with any API or database library. This approach lets you focus on domain model which will enable Domain-Driven Development for applications. EF code first support is currently enabled with a separate API that is runs on top of the Entity Framework 4.

Step 3. Creating Repositories/Contexts :

Our next step is to create the contexts/repositories for our application and classes that will interact with the database.

A. Create Context Class for Entity Framework :

We have already prepared our domain model now let’s create a class in order to working with Entity Framework Code First. I have added reference to EntitFramework.dll CTP 4.1 to this class library project. We create two folders DBInteractions and EntityRepositories to segregate our classes as in fig5, we’ll come to that later, first let me explain you the context class.

(fig 5)

(fig 6)

The above class CodeFirstContext in fig 6 is derived from DbContext that can connect your model classes to a database. The CodeFirstContext class is mapping our Student class to

database tables Student use DbSet where TEntity is any POCO class. When we arerunning the application at first time, it will automatically create the database. EF code-first look for a connection string in web.config or app.config that has the same name as the dbcontext class. If it is not find any connection string with the convention, it will automatically create database in local SQL Express database by default and the name of the database will be same name as the dbcontext class. You can also define the name of database in constructor of the the dbcontext class. The model classes of Code First are working on the basis of conventions and we can also use a fluent API to refine our model. The convention for primary key is ‘Id’ or ‘Id’ as I discussed before. If primary key properties are detected with type ‘int’, ‘long’ or ‘short’, they will automatically registered as identity columns in the database by default. Primary key detection is not case sensitive. We can define our model classes with validation attributes in the System.ComponentModel.DataAnnotations namespace and it automatically enforces validation rules when a model object is updated or saved.

I ) DBInteractions :

B. Generic Repository for EntityFramework Code First:

We have now created model class and dbcontext class. Now we create a generic repository pattern for data persistence with EF code first. Let’s create a generic repository to working with DbContext and DbSet as follows,The following classes will be added to DBInteractions folder for ease of understanding logic.

(fig 7)
1. DataBase Factory:
We have our database factory class defined as follows,

(fig 8)

(fig 9)

Where IDBFactory is the interface implemented by our factory class DBFactory.The factory class is inherited from Disposable class as shown below in fig 10,Responsible for releasing disposing database resources.

(fig 10)
1. RepositoryBase – The Generic Entity Repository base class :
  
  Above is the repository base class that contains all the methods to be implemented for CRUD DB operations, we can define more of our generic methods here, for now considering our application, these are eough for proper understanding of the working.
  
  E. Unit of Work
  
  The Unit of Work pattern maintains a list of objects affected by a business transaction and coordinates the writing out of changes and the resolution of concurrency problems.We create a class for handling Unit of Work pattern,
  
  Interface :
  
  Class :
  
  The Commit method written in of the UnitOfWork will call the commit method of our Context class and it will execute the SaveChanges method of DbContext class.
  
  II ) Repository :
  
  In this article, we will be primarily focus on the persistence against Student entity . Let’s create a repository for handling CRUD operations for Student
  
  using derive from a generic Repository EntityRepositoryBase.
  
  Repository class for Student :
  
  Interface :
  
  Class :
Step 4. Creating a Service layer :

Service Layer defines an application’s scope and its available set of operations from the perspective of interfacing client layers. It encapsulates the application’s business logic,

controlling transactions and coordinating responses in the implementation of its operations. Controller classes should be made light and do not put much of business logic onto it. We can use

the service layer as the business logic layer and can encapsulate the rules of the application.

We define interfaces and corresponding student service for our application business logic,Since we are targetting CRUD operations, so the methods are quite simple in implementation,

Interface :

As we can see in abve interface the methods are to Get Student Details,List,Update and Delete Student.

Class :

usingSystem.Collections.Generic;

usingCodeFirstData.DBInteractions;

usingCodeFirstData.EntityRepositories;

usingCodeFirstEntities;

usingCodeFirstServices.Interfaces;

namespaceCodeFirstServices.Services

{

publicclassStudentService: IStudentService

{

privatereadonlyIStudentRepository_studentRepository;

privatereadonlyIUnitOfWork_unitOfWork;

publicStudentService(IStudentRepositorystudentRepository, IUnitOfWorkunitOfWork)

{

this._studentRepository = studentRepository;

this._unitOfWork = unitOfWork;

}

#regionIStudentService Members

publicIEnumerable<Student> GetStudents()

{

varstudents = _studentRepository.GetAll();

returnstudents;

}

publicStudentGetStudentById(intid)

{

varstudent = _studentRepository.GetById(id);

returnstudent;

}

publicvoidCreateStudent(Studentstudent)

{

_studentRepository.Add(student);

_unitOfWork.Commit();

}

publicvoidDeleteStudent(intid)

{

varstudent = _studentRepository.GetById(id);

_studentRepository.Delete(student);

_unitOfWork.Commit();

}

publicvoidUpdateStudent(Studentstudent)

{

_studentRepository.Update(student);

_unitOfWork.Commit();

}

publicvoidSaveStudent()

{

_unitOfWork.Commit();

}

#endregion

}

}

Class uses refernces of Repositories and Entities, and Dependency of Repositories is resolved in Constructor of the service itself.

Step 5. The MVC Portal :

Before we start MVC portal,Lets clear our logic for IOC and DI.I have already discussed IOC in the article.For resolving Dependency we create certain classes as discussed below, to get independent service request,

We also create a custom lifetime manager for Unity to store container in the current HttpContext.

publicclassHttpContextLifetimeManager : LifetimeManager, IDisposable

{

publicoverrideobjectGetValue()

{

varassemblyQualifiedName = typeof(T).AssemblyQualifiedName;

if(assemblyQualifiedName != null)

returnHttpContext.Current.Items[assemblyQualifiedName];

returnnull;

}

publicoverridevoidRemoveValue()

{

varassemblyQualifiedName = typeof(T).AssemblyQualifiedName;

if(assemblyQualifiedName != null)

HttpContext.Current.Items.Remove(assemblyQualifiedName);

}

publicoverridevoidSetValue(objectnewValue)

{

varassemblyQualifiedName = typeof(T).AssemblyQualifiedName;

if(assemblyQualifiedName != null)

HttpContext.Current.Items[assemblyQualifiedName] = newValue;

}

publicvoidDispose()

{

RemoveValue();

}

}

}

We create a dependency resolver for resolving service dependency as follows,

ASP.NET MVC 3 has introduced a new interface IControllerActivator which lets you activate controllers with custom behavior and can be use it for dependency injection purpose.The

IControllerActivator interface is discoverable using the dependency resolver. Let’s create a custom controller activator class by deriving from IControllerActivator intreface

usingSystem;

usingSystem.Web.Mvc;

namespaceCodeFirstPortal.IoC

{

publicclassCustomControllerActivator: IControllerActivator

{

IControllerIControllerActivator.Create(

System.Web.Routing.RequestContextrequestContext,

TypecontrollerType){

returnDependencyResolver.Current

.GetService(controllerType) asIController;

}

}

}

We also create a UnityController Factory and Configure contract and concrete types of unity in global.asax file.

ASP.NET MVC 3 has also introduced a new interface IDependencyResolver which exposes two methods – GetService and GetServices.The GetService method resolves singly registered services

that support arbitrary object creation and the GetServices resolves multiply registered services. Implementations of the IDependencyResolver interface should delegate to the underlying

dependency injection container to provide the registered service for the requested type. When there are no registered services of the requested type, the ASP.NET MVC framework expects

implementations of this interface to return null from GetService and to return an empty collection from GetServices. Let’s create a custom dependency resolver class by deriving from

IDependencyResolver intreface in order to working with Unity to providing dependency injection.

usingSystem;

usingSystem.Web;

usingSystem.Web.Mvc;

usingSystem.Web.Routing;

usingMicrosoft.Practices.Unity;

namespaceCodeFirstPortal.IoC

{

publicclassUnityControllerFactory: DefaultControllerFactory

{

IUnityContainercontainer;

publicUnityControllerFactory(IUnityContainercontainer)

{

this.container = container;

}

protectedoverrideIControllerGetControllerInstance(RequestContextreqContext, TypecontrollerType)

{

IControllercontroller;

if(controllerType == null)

thrownewHttpException(

404, String.Format(

“The controller for ‘{0}‘ could not be found”+ “or it does not implement IController.”,

reqContext.HttpContext.Request.Path));

if(!typeof(IController).IsAssignableFrom(controllerType))

thrownewArgumentException(

string.Format(

“Requested type is not a controller: {0}“,

controllerType.Name),

“controllerType”);

try

{

controller= container.Resolve(controllerType) asIController;

}

catch(Exceptionex)

{

thrownewInvalidOperationException(String.Format(

“Error resolving the controller {0}“,

controllerType.Name), ex);

}

returncontroller;

}

}

Resolving Service Dependency :

usingSystem;

usingSystem.Collections.Generic;

usingSystem.Web.Mvc;

usingMicrosoft.Practices.Unity;

namespaceCodeFirstPortal.IoC

{

publicclassUnityDependencyResolver: IDependencyResolver

{

IUnityContainercontainer;

publicUnityDependencyResolver(IUnityContainercontainer)

{

this.container = container;

}

publicobjectGetService(TypeserviceType)

{

try

{

returncontainer.Resolve(serviceType);

}

catch

{

returnnull;

}

}

publicIEnumerable<object> GetServices(TypeserviceType)

{

try

{

returncontainer.ResolveAll(serviceType);

}

catch

{

returnnewList<object>();

}

}

}

}

global.asax :

Add service project reference , entity project reference and data project reference to the portal.

The SetResolver method of DependencyResolver class provides a registration point for dependency injection containers. In this method, we configure the UnityDependencyResolver class for

providing dependency injection with Unity 2.0. The SetResolver method will be working with any dependency injection container.If you want to use StructureMap as the dependency injection

container, you can create a dependency resolver class in order to working with StructureMap by deriving IDependencyResolver intreface and later you can configure this class with SetResolver

method. The ASP.NET MVC 3 is providing a good support for working with dependency injection containers.

usingSystem.Web.Mvc;

usingSystem.Web.Routing;

usingCodeFirstData.DBInteractions;

usingCodeFirstData.EntityRepositories;

usingCodeFirstPortal.IoC;

usingCodeFirstServices.Interfaces;

usingCodeFirstServices.Services;

usingMicrosoft.Practices.Unity;

namespaceMvcPortal

{

publicclassMvcApplication: System.Web.HttpApplication

{

publicstaticvoidRegisterGlobalFilters(GlobalFilterCollectionfilters)

{

filters.Add(newHandleErrorAttribute());

}

publicstaticvoidRegisterRoutes(RouteCollectionroutes)

{

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

routes.MapRoute(

“Default”, // Route name

“{controller}/{action}/{id}”, // URL with parameters

new{ controller = “Home”, action = “Index”, id = UrlParameter.Optional } // Parameter defaults

);

}

protectedvoidApplication_Start()

{

AreaRegistration.RegisterAllAreas();

RegisterGlobalFilters(GlobalFilters.Filters);

RegisterRoutes(RouteTable.Routes);

IUnityContainercontainer = GetUnityContainer();

DependencyResolver.SetResolver(newUnityDependencyResolver(container));

}

privateIUnityContainerGetUnityContainer()

{

//Create UnityContainer

IUnityContainercontainer = newUnityContainer()

.RegisterType<IDBFactory, DBFactory>(newHttpContextLifetimeManager<IDBFactory>())

.RegisterType<IUnitOfWork, UnitOfWork>(newHttpContextLifetimeManager<IUnitOfWork>())

.RegisterType<IStudentService, StudentService>(newHttpContextLifetimeManager<IStudentService>())

.RegisterType<IStudentRepository, StudentRepository>(newHttpContextLifetimeManager<IStudentRepository>());

returncontainer;

}

}

}

To Start with MVC our first step is to define our connection string as follows in the web.config file.

Steps to Create Controllers and Views :
1. We start with home Controller, as it is the default controller set in global.asax to be called first.
1. We create Student Controller, We define actions in the controller for each operation we want to perform as follows,
usingSystem;

usingSystem.Linq;

usingSystem.Web.Mvc;

usingCodeFirstEntities;

usingCodeFirstServices.Interfaces;

namespaceCodeFirstPortal.Controllers

{

publicclassStudentController: Controller

{

privatereadonlyIStudentService_studentService;

publicStudentController(IStudentServicestudentService)

{

this._studentService = studentService;

}

[HttpGet]

publicActionResultDetails(int? id)

{

varstudentDetails = _studentService.GetStudentById((int) id);

if(studentDetails == null) thrownewArgumentNullException(“Not Found”);

returnView(studentDetails);

}

[HttpGet]

publicActionResultDelete(int? id)

{

varstudentDetails = _studentService.GetStudentById((int) id);

if(studentDetails == null) thrownewArgumentNullException(“Not Found”);

returnView(studentDetails);

}

[HttpPost]

publicActionResultDelete(Studentstudent)

{

_studentService.DeleteStudent(student.StudentId);

returnRedirectToAction(“List”, “Student”);

}

[HttpGet]

publicActionResultEdit(int? id)

{

varstudentDetails = _studentService.GetStudentById((int) id);

if(studentDetails == null) thrownewArgumentNullException(“Not Found”);

returnView(studentDetails);

}

[HttpPost]

publicActionResultEdit(Studentstudent)

{

_studentService.UpdateStudent(student);

returnRedirectToAction(“List”, “Student”);

}

[HttpGet]

publicActionResultCreate()

{

returnView();

}

[HttpPost]

publicActionResultCreate(Studentstudent)

{

varstudentModel = newStudent()

{

Address = student.Address,

Country = student.Country,

Name = student.Name,

Age = student.Age,

Email = student.Email

};

_studentService.CreateStudent(studentModel);

returnRedirectToAction(“List”, “Student”);

}

[HttpGet]

publicActionResultList()

{

varstudents = _studentService.GetStudents();

if(students.Any())

{

returnView(“List”, students);

}

returnView(“List”);

}

}

}

There are get and corresponding Posts for each method responsible for Data Updations. The Constructor of the controller initializes the Service,we can see it do not create direct instance.
1. We Create Views for every Action,Its easy if we right click the controller action and create view,It automatically create a view with a Default folder named in the name of Constructor,So we can create all the views for our operations, and our solution looks like,
  
  4. Now we are ready with our application to be executed,keep your fingers crossed and see the magic, I have used _layout as master page to give some meaningful look and feel to my application,U can customize the same.When u run the application by pressing F5, We get redirected to the Index view of Student Controller,which shows list of students,since we are running it first time,we dont have existing list, and our application shows,
  1. No wonder , just have a look at your DataBase, My case I am using Sql Server 2008,
    
    I got a Database created automativcally with the name CodeFirstApp having Student Table, Now you can cross verify the table with your entity,its the same.So we have hit the target and our database is successfully created.
    1. Further Operations :
    You can now test the application and perform further CRUD operations in the application and see the DataBase getting updated.e.g. Create Student,
    
    after Submit by pressing Create, we get,
    
    therefore one student created.
    
    We can edit the same student by pressing edit link , we get the view,
    
    Likewise we can see the details of already created student,
    
    and delete the student will redirect to ,
    
    I had created 3 students in the same manner, You can create more and play with the application.
    
    Risk Factor : There is also a Risk Factor in implementing EntityFramework, If we do any change in the entity, like deleting,changing property,The context will drop and recreate the database, which may clearly lead to loss of your existing data.To avoid this critical situation, we code some more, we call SetInitializer method of DataBase class and set it to null in our dataBase Factory Class.
    
    usingSystem.Data.Entity;
    
    namespaceCodeFirstData.DBInteractions
    
    {
    
    publicclassDBFactory: Disposable, IDBFactory
    
    {
    
    publicDBFactory()
    
    {
    
    Database.SetInitializer<CodeFirstContext>(null);
    
    }
    
    privateCodeFirstContextdataContext;
    
    publicCodeFirstContextGet()
    
    {
    
    returndataContext ?? (dataContext = newCodeFirstContext());
    
    }
    
    protectedoverridevoidDisposeCore()
    
    {
    
    if(dataContext != null)
    
    dataContext.Dispose();
    
    }
    
    }
    
    }
    
    Database class is from namespace System.Data.Entity, whcih provides such feature.
    
    Conclusion :
    
    In this article we discussed about creating an application using EntityFramework 4.1 Code First Approach, We used Inversion of control and Dependency Injection to Resolve Dependency between layers.We used MVC 3 razor view engine as our UI and integrated the layers to acheive our objective.The application was a description of simple CRUD operations on Database.We learned how to use Repository Pattern,Unit of Work pattern and Unity Framework.You can download the codebase and further enhance/extend it according to your need.Happy Coding.
    Learn Complete MVC Step by Step:
    Articles : http://www.codeproject.com/script/Articles/BlogFeedList.aspx?amid=7869570

Read more:

Other Series