Introduction
Here are some useful tips which we can look into while working on ASP.NET MVC project:
ViewEngine
inside MVC is a to produce HTML (known as Razor) - HTML 5 has HTML tag with
lang="en"
to specify the default language - Meta tag with
charset="utf-8"
which specifies cross site scripting from some other sites do not harm our website. - Meta tag with
name="viewport"
is used for mobile devices. Without this meta tag, mobile assumes that your page needs 900px to display properly. With this meta tag, we are telling the device not to assume anything. Page fill fits the width of device automatically. - The script tag
src="/Scripts/modernizr-2.5.3.js"
. This supports that HTML5 markup will work for every browser, even in IE-6. - Controller - Incoming HTTP Request goes to controller.
- Model - Controller is responsible for calling Model. Model contains all the information that use needs to see.
- View - Controller selects View to display model. It’s just a template.
- MVC- It’s a design pattern to follow when you want to separate responsibilities of the components.
- MVC is testable. Specially, Controller should be testable.
- Naming convention plays a big role in MVC.
- View has cshtml extension.
ViewBag
is dynamically typed object inside MVC C#. - Models can reside in any Folder, even in a different Project.
- Routing engine is the core part of ASP.NET. It’s not tide up to MVC. It can be used in webforms, WCF, webservices and MVC.
- Routing engine
MapRoute
API provides a friendly name for URL, a pattern for route and parameters for route and default. Its job is to examine the URL and figure out where to send it for processing. - Controller Invokes Action. Looks for certain
ActionName
method. - Razor View is the cshtml extension. Consider them as a markup to display data inside the markup.
- Heavy Calculation logic is not in the Views.
- Views automatically handles HTML encoding.
- Inside
@{}
, we can out C# code in a View. - Inside C# code in
View
, if we want some static or HTML text, we have to use @:
before the text to be displayed. RenderBody()
method will render the .cshtml page to generate UI output. - _ViewStart.cshtml is the file which describes the common Layout for the application.
RenderSection()
method is used to render sections defined anywhere within the View
. It also deals in Ajax. - HTML helpers inside Views are helpful in creating action links, edit and validations and many others.
- Anonymous objects are used heavily in MVC
TryUpdateModel()
method goes through the process of Model Binding. Model Binder looks around for Update and updates the values. - How to build a custom logic in a Views? (need to drill this in depth)
- Partial Views are used for re-usability across various views.
Html.Action()
helper can be called in a _layout
. It will call a sub-request to further call another Controller
that builds its own Model
independent of what the main controller is doing and render its own view, which is a partial view. It’s not a separate HTTP Request. - How Entity Framework populates Schema, it can be done by using EF-Migration. Migrations in EF is a tool which allows to configure schema with C# code and can keep the schema in sync with C# code for any changes. Example: in PM, type
Enable-Migration -ContentTypeName "DBclassname"
AddOrUpdate()
method in EF DbContext
automatically checks in records exist then update it or insert it. - LinQ queries are strongly typed. That is the compiler and VS knows about the type of data we are querying against. LinQ uses Comprehension Query Syntax and Extension Method Syntax (Lambda Expression, useful for custom paging also).
- Projection can be used to get columns to be listed inside Linq queries in C# code.
- Example:
Select aliasname;
- The class which defines an extension method must be non-generic and static
- Every extension method must be a
static
method. - Very often, our page needs more information than our
Entity
can have. In such situations, we use View-Model. Projection can be helpful here. - Using Comprehension expression or Extended expression doesn't affect in query performance anyway. It’s just another way to write the same query.
- While developing, we should be very clear when to use method "
get
" and when to use "post
". Usually get
operation is a read operation and post
operation is save, update, delete or process something on server. - While designing a search page, we can use
get
method as it's just reading the values and displaying to user. The get
method wraps up the input in a query string to process request. - ASP.NET MVC matches things in Request by name.
- Virtual keyword will create a wrapper at runtime.
- Before CRUD operations, check
ModelState IsValid
. - If you don't want to update any specific field, use
[Bind()]
attribute with value Exclude="fieldname, can be comma separated"
- Another way to do the same is to use a View-Model which will have properties defined inside it only.
- The
DataAnotations
are used for Validations inside Model
. - Custom Validation Attributes can be used for custom Validation on various pages.
- Also implement
IValidatableObject interface
. - Inside Scripts folder, there is _refrences.js file which references the commonly used js files.
- knockout.js is used in Model-View View-Model design pattern. It provides scripts like declarative data binding.
- modernizer file is used to detect and run HTML 5 features on various browsers.
- jquery.in.js is minified file having no comments or spaces so that browser can load the files faster.
- jquery.unobtrusive-ajax.js acts like a bridge between jquery and ASP.NET MVC. It uses validations by supplying metadata to jquery validation.
- Bundling can bundle number of files into a single file @ runtime. Inside Global.asax, in
Application_Start
, there is Bundle.config RegisterBundle
. @Scripts.Render("~/bundles/modenizr")
- When we are running the application in release mode, there is only one file to be downloaded by the browser, while in debug mode, all files bundled are present for download each.
Ajax.BeginForm
makes asynchronous request to the server; whereas BeginHtmlForm
makes synchronous request to the server which means full postback on server. - Inside the controller, we can check
if (Request.IsAjaxRequest()) {//do this}
- There are three MVC features of unobtrusive JavaScript.
- These are
Ajax.BeginForm
, Ajax.ActionLink
-> to make asynchronous request and update the screen instead of navigating browser to a new page. - Client Side Validation - > Unobtrusive JavaScript means we don't have JavaScript on click events, because that's obtrusive js to read the code and it also means to work if JavaScript on our browser in disabled, even then it will work because of its asynchronous postback.
- using data- attributes, we can customize things like handling Ajax by using client side JavaScript instead and customizing messages, etc.
- Jquery autocomplete UI documentation says, json should have a label property or value or both.
- For Custom Paging, we use
PagedList
and PagedList.Mvc
. - Authentication: Forms based (cookies, SSL required for security), OpenID/ OAuth (Third party like Microsoft or Twitter), Windows Authentication (Windows operating system auth with active directory and single sign on)
- WebMatrix/WebSecurity is being used to borrow some features like Forms Authentication features from standard ASP.NET.
SimpleMemberShipProvider
- Cross site Request Forgery ->
[ValidateAntiForgeryToken]
: Put it on all submit forms and also on cshtml files @Html.AntiForgeryToken()
- ASP.NET MVC supports OpenID/OAuth via
DotnetOpenAuth
OutputCache
can be used to Cache data on Server, Client or Server-Client both (by using some proxy server in between). VaryByHeader="X-Requested-With"
is used for Ajax request. Also set Location=OutputCacheLocation.Server
. - Caching can be best tested in production env. while testing.
- Always use Cache Profile in config file instead of hard coding values.
- While working on Resources files, make sure that the Access Modifier for resx file is set to
Public
, because Razor files are compiled separately as public
and it can only access resx files if the files are public access. VaryByHeader="X-Requested-With;Accept-Language"
is used when dealing with resources files for multi-lingual support. - Use elmah for error handling.
- Start developing Unit test cases sitting with Business Development/QA Team to develop possible test cases and Run All test cases.
- Deployment & Testing are the most important part while developing a ASP.NET MVC application.
- For CSS that are reused among the entire site, I define them in the section of the
_Layout:<br />
@RenderSection("Styles", false)
and if I need some view specific styles, I define the Styles
section in each view: @section Styles {}
- ASP.NET Web API is a framework for building web APIs on top of the .NET Framework.
- A controller is an object that handles HTTP requests.
- Controllers in Web API derive from the
ApiController
class instead of Controllerclass
. - The first major difference you will notice is that actions on Web API controllers do not return views, they return data.
- The
getJSON
function sends the AJAX request. The response will be an array of JSON objects. The second parameter to getJSON
is a callback function that is invoked when the request successfully completes. - Understanding Routing
- For each HTTP message, the ASP.NET Web API framework decides which controller receives the request by consulting a route table.
- When you create a new Web API project, the project contains a default route that looks like this:
/api/{controller}/{id}
- The
{controller}
and {id}
portions are placeholders. - When the framework sees a URI that matches this pattern, it looks for a controller method to invoke, as follows:
{controller}
is matched to the controller name. - The HTTP request method is matched to the method name. (This rule applies only to
GET
, POST
, PUT
, and DELETE
requests.) {id}
, if present, is matched to a method parameter named id
. - Query parameters are matched to parameter names when possible
- In ASP.NET Web API, a controller is a class that handles HTTP requests. The
public
methods of the controller are called action methods or simply actions. When the Web API framework receives a request, it routes the request to an action. - The four main HTTP methods (
GET
, PUT
, POST
, and DELETE
) can be mapped to CRUD operations as follows:
GET
retrieves the representation of the resource at a specified URI. GET
should have no side effects on the server. PUT
updates a resource at a specified URI. PUT
can also be used to create a new resource at a specified URI, if the server allows clients to specify new URIs. For this tutorial, the API will not support creation through PUT. POST
creates a new resource. The server assigns the URI for the new object and returns this URI as part of the response message. DELETE
deletes a resource at a specified URI.
Note: The PUT
method replaces the entire product entity. That is, the client is expected to send a complete representation of the updated product. If you want to support partial updates, the PATCH
method is preferred.
- In Web API, parameters with complex types are DE serialized from the request body.
Point of Interest
There are many more important points which we will come across while working on ASP.NET MVC application. These tips can be useful while cracking an interview as well. So it's always good practice to have such tips handy on the internet so that we can reference them any time they are needed.