Cascading drop-down list in asp.net Grid view | Dependent Dropdownlist inside GridView

Here i am going to explain how to do cascading drop down list in asp.net webform.code is copied from my project so not able to formatted properly due to lack of time.but you see the code and understand the implementation.

.aspx code

OnRowCommand="gvCity_RowCommand" OnRowEditing="gvCity_RowEditing" OnRowCancelingEdit="gvCity_RowCancelingEdit"
 OnRowUpdating="gvCity_RowUpdating" OnRowDeleting="gvCity_RowDeleting" ShowFooter="True"
 PageSize="20" Width="100%">
 runat="server">
 AutoPostBack="true" OnSelectedIndexChanged="ddlNewCountrygvCity_SelectedIndexChanged"
 Visible="false" runat="server">
 runat="server">
 Visible="false" Enabled="false" runat="server">
 Visible="false">
 OnClientClick="return CityUpdateValidate();" ImageUrl="~/Image/update.png" ToolTip="Update"
 ToolTip="Cancel" ImageUrl="~/Image/cancel.png" />
 CommandName="AddNew" ToolTip="Add New" />
 OnClick="ibtnNewCityInsert_Click" ImageUrl="~/Image/add.png" Visible="false"
 ToolTip="Insert" /> 
 ToolTip="Cancel" ImageUrl="~/Image/cancel.png" Visible="false" />
 ImageUrl="~/Image/img_edit.png" ToolTip="Edit" />
 ImageUrl="~/Image/img_delete.png" OnClientClick="return ConfirmDelete();" ToolTip="Delete"

 .cs code
 public void gvCityBind()
 {
 dsCity = SqlHelper.ExecuteDataset(connectionString, "genCityMaster_SelectDelete", 0, "NULL", "S");
 if (dsCity.Tables[0].Rows.Count > 0)
 {
 gvCity.DataSource = dsCity;
 gvCity.DataBind();
 }
 else
 {
 NoDataFound(dsCity, gvCity);
 SrNoCity = 1;
 }
 }
 protected void gvCity_PageIndexChanging(object sender, GridViewPageEventArgs e)
 {
 gvCity.PageIndex = e.NewPageIndex;
 gvCityBind();
 }
 protected void gvCity_RowDataBound(object sender, GridViewRowEventArgs e)
 {
 if (e.Row.RowType == DataControlRowType.DataRow)
 {
 Label lblSrNo = (Label)e.Row.FindControl("lblSrNo");
 lblSrNo.Text = Convert.ToString(gvCity.PageIndex * gvCity.PageSize + SrNoCity);
 SrNoCity++;
 DropDownList ddlCountry = (DropDownList)e.Row.FindControl("ddlCountry");
 DropDownList ddlState = (DropDownList)e.Row.FindControl("ddlState");
 if (ddlCountry != null)
 {
 ddlCountry.DataSource = objCountryBLL.SelectCounrty();
 ddlCountry.DataBind();
 ddlCountry.SelectedValue = dsCity.Tables[0].Rows[e.Row.RowIndex]["CountryId"].ToString();
 }
 if (ddlState != null)
 {
 ddlState.DataSource = objStateBLL.SelectState(Convert.ToInt32(ddlCountry.SelectedValue));
 ddlState.DataBind();
 ddlState.SelectedValue = dsCity.Tables[0].Rows[e.Row.RowIndex]["StateId"].ToString();
 }
 }
 if (e.Row.RowType == DataControlRowType.Footer)
 {
 DropDownList ddlNewCountry = (DropDownList)e.Row.FindControl("ddlNewCountry");
 DropDownList ddlNewState = (DropDownList)e.Row.FindControl("ddlNewState");
 if (ddlNewCountry != null)
 {
 ddlNewCountry.DataSource = objCountryBLL.SelectCounrty();
 ddlNewCountry.DataBind();
 }
 if (ddlNewState != null)
 {
 ddlNewState.DataSource = objStateBLL.SelectState(Convert.ToInt32(ddlNewCountry.SelectedValue));
 ddlNewState.DataBind();
 }
 }
 }
 protected void gvCity_RowCommand(object sender, GridViewCommandEventArgs e)
 {
 try
 {
 if (e.CommandName.Equals("AddNew"))
 {
 gvCity.EditIndex = -1;
 gvCityBind();
 gvCity.FooterRow.CssClass = objCommonDAL.GetGrigViewFooterStyle();
 Label lblNewSrNo = (Label)gvCity.FooterRow.FindControl("lblNewSrNo");
 lblNewSrNo.Text = SrNoCity.ToString();
 ImageButton ibtnNewCityInsert = (ImageButton)gvCity.FooterRow.FindControl("ibtnNewCityInsert");
 ImageButton imgbtnNewCancel = (ImageButton)gvCity.FooterRow.FindControl("imgbtnNewCancel");
 ImageButton imgbtnNewAdd = (ImageButton)gvCity.FooterRow.FindControl("imgbtnNewAdd");
 ibtnNewCityInsert.Visible = true;
 imgbtnNewCancel.Visible = true;
 imgbtnNewAdd.Visible = false;
 DropDownList ddlNewCountry = (DropDownList)gvCity.FooterRow.FindControl("ddlNewCountry");
 ddlNewCountry.Visible = true;
 ddlNewCountry.Focus();
 DropDownList ddlNewState = (DropDownList)gvCity.FooterRow.FindControl("ddlNewState");
 ddlNewState.Visible = true;
 TextBox txtNewCity = (TextBox)gvCity.FooterRow.FindControl("txtNewCity");
 txtNewCity.Visible = true;
 }
 }
 catch (Exception ex)
 {
 throw ex;
 }
 }
 protected void ibtnNewCityInsert_Click(object sender, ImageClickEventArgs e)
 {
 try
 {
 objCity.StateId = Convert.ToInt32(((DropDownList)gvCity.FooterRow.FindControl("ddlNewState")).SelectedValue);
 objCity.CityName = Convert.ToString(((TextBox)gvCity.FooterRow.FindControl("txtNewCity")).Text);
 objCity.CreatedBy = Convert.ToInt32(UserId);
 objCity.ModifiedBy = Convert.ToInt32(UserId);
 objCity.CreatedOn = System.DateTime.Now;
 objCity.ModifiedOn = System.DateTime.Now;
 try
 {
 int intResultInsert = objCityBLL.InsertCity(objCity);
 if (intResultInsert > 0)
 {
 exceptionMessage.Text = "Record Added Successfully !";
 gvCity.EditIndex = -1;
 gvCityBind();
 }
 else
 {
 exceptionMessage.Text = "This record already exists !";
 }
 }
 catch (Exception ex)
 {
 exceptionMessage.Text = ex.Message.ToString();
 }
 finally
 {
 objCityBLL = null;
 }
 }
 catch (Exception ex)
 {
 throw ex;
 }
 }
 protected void gvCity_RowEditing(object sender, GridViewEditEventArgs e)
 {
 gvCity.EditIndex = e.NewEditIndex;
 gvCityBind();
 }
 protected void gvCity_RowCancelingEdit(object sender, GridViewCancelEditEventArgs e)
 {
 gvCity.EditIndex = -1;
 gvCityBind();
 }
 protected void gvCity_RowUpdating(object sender, GridViewUpdateEventArgs e)
 {
 try
 {
 objCity.CityId = Convert.ToInt32(((Label)gvCity.Rows[e.RowIndex].FindControl("lblCityId")).Text);
 objCity.StateId = Convert.ToInt32(((DropDownList)gvCity.Rows[e.RowIndex].FindControl("ddlState")).SelectedValue);
 objCity.CityName = Convert.ToString(((TextBox)gvCity.Rows[e.RowIndex].FindControl("txtCity")).Text);
 objCity.CreatedBy = Convert.ToInt32(UserId);
 objCity.ModifiedBy = Convert.ToInt32(UserId);
 objCity.CreatedOn = System.DateTime.Now;
 objCity.ModifiedOn = System.DateTime.Now;
 int intResultUpdate = objCityBLL.UpdateCity(objCity);
 if (intResultUpdate > 0)
 {
 exceptionMessage.Text = "Record Updated Successfully !";
 gvCity.EditIndex = -1;
 gvCityBind();
 }
 }
 catch (Exception ex)
 {
 exceptionMessage.Text = ex.Message.ToString();
 }
 finally
 {
 objCityBLL = null;
 }
 }
 protected void gvCity_RowDeleting(object sender, GridViewDeleteEventArgs e)
 {
 try
 {
 objCity.CityId = (int)gvCity.DataKeys[e.RowIndex].Value;
 int result = objCityBLL.DeleteCity(objCity);
 if (result > 0)
 {
 exceptionMessage.Text = "Row Deleted Successfully...!";
 gvCity.EditIndex = -1;
 gvCityBind();
 }
 }
 catch (Exception ex)
 {
 exceptionMessage.Text = ex.Message.ToString();
 }
 }
 protected void ddlNewCountrygvCity_SelectedIndexChanged(object sender, EventArgs e)
 {
 DropDownList ddlNewCountry = (DropDownList)gvCity.FooterRow.FindControl("ddlNewCountry");
 DropDownList ddlNewState = (DropDownList)gvCity.FooterRow.FindControl("ddlNewState");
 if (Convert.ToInt32(ddlNewCountry.SelectedValue) > 0)
 {
 ddlNewState.Enabled = true;
 ddlNewState.DataSource = objStateBLL.SelectState(Convert.ToInt32(ddlNewCountry.SelectedValue));
 ddlNewState.DataBind();
 }
 else
 {
 ddlNewState.Enabled = false;
 }
 } 

Read More

Different return types of asp.net mvc controller action method

Q.What are different return types of a controller action method?

Answer: There are total nine return types we can use to return results from controller to view. The base type of all these result types is ActionResult.

1. ViewResult (View): View Result is used to return a webpage from an action method.
2. PartialviewResult (Partialview): PartialViewResult is used to send a part of a view which will be rendered in another view.
3. RedirectResult (Redirect): RedirectResult is used to redirect to any other controller and action method depending on the URL.
4. RedirectToRouteResult (RedirectToAction, RedirectToRoute): This return type is used when we want to redirect to any other action method.
5. ContentResult (Content): RedirectToRouteResult is used to return HTTP content type like text/plain as the result of the action.
6. jsonResult (json): jsonResult is used when we want to return a JSON message.
7. javascriptResult (javascript): javascriptResult is used to return JavaScript code that will run in browser.
8. FileResult (File): FileResult is used to send binary output in response.
9. EmptyResult: EmptyResult is used to return nothing (void) in the result.

Read More

Page lifecycle of an ASP.NET MVC | ASP.NET page life cycle

Q.Explain “Page Life Cycle” of an ASP.NET MVC?

Ans.In traditional ASP.NET webform application each asp.net page implements the IHTTPHandler interface.

This interface has a ProcessRequest() method that gets called when you request the page. The ProcessRequest() method is responsible for processing the request and generating the response. So in asp.net application it is simple, you request for a page in the url like http://mylocalsite1\default.aspx and then it search for that page on the local disk and execute the processrequest method and generate the html response.

However in MVC application ,request response process is different from webform. In MVC there are no physical page exist for a particular request. All the requests are routed to a special class called Controller. The controller is responsible for generating the response and sending the content back to the browser.

When you build a MVC application you can define a bunch of controllers. Each controller can handle multiple requests. For example, all the following will route to same Controller.

These requests will execute the same Controller Controller1 and in that it will extract the id from the URL and process the request. This gives more readable URL then asp.net page.

So how these requests are routed to particular controller. Now the RouteTable come into the picture. Every ASP.NET MVC application has a RouteTable. This routetable is responsible to map the mvc requests to particular controller.

public class MvcApplication : System.Web.HttpApplication
{
public static void RegisterRoutes(RouteCollction routes)
{
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
);
    }

protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
RegisterRoutes(RouteTable.Routes);
}
}

When Application Start the Application_Start events will get called and it will call the method RegisterRoutes which will send the collection of Routes as the parameter and the routes will be added to this Collection which is a Dictionary of NamedMaps.

Each route also references a handler which will handle the rest of the request. When we use MapRoute, what we really do is creating a route by instantiating the 3 dictionaries and defining the default MVC handler: PageRouteHandler. Each RouteHandler implements an interface IRouteHandler.

public Route MapPageRoute(string routeName, string routeUrl, string physicalFile, bool checkPhysicalUrlAccess, RouteValueDictionarydefaults,   RouteValueDictionary constraints, RouteValueDictionary dataTokens) { if (routeUrl == null) { throw new ArgumentNullException("routeUrl"); } Route item = new Route(routeUrl, defaults, constraints, dataTokens, new PageRouteHandler(physicalFile, checkPhysicalUrlAccess)); this.Add(routeName, item); return item; } Step 2: The URL Routing Module intercepts the request. Whenever you make a request against an ASP.NET MVC application, the request is intercepted by the UrlRoutingModule HTTP Module.  When the UrlRoutingModule intercepts a request, the first thing the module does is to wrap up the current HttpContext in an HttpContextWrapper object. The HttpContextWrapper object derives from HTTPContextBase class. private void OnApplicationPostResolveRequestCache(object sender, EventArgs e) { HttpApplication application = (HttpApplication) sender; HttpContextBase context = new HttpContextWrapper(application.Context); this.PostResolveRequestCache(context); } Then the module send this contextBase object to the method called PostResolveRequestCache . Based on the Context it will return the correct RouteData from the RouteTable which was created in the earlier step based on the URL, form parameters and query string parameters associated with the HTTPContext object.  If the UrlRoutingModule successfully retrieves a RouteData object then the module next creates a RouteContext object that represents the current HttpContext and RouteData. The module then instantiates a new HttpHandler based on the RouteTable and passes the RouteContext to the new handler’s constructor.  In the case of an ASP.NET MVC application,the handler returned from the RouteTable will always be an MvcHandler. This MVCHandler also derive from interface IHTTPHandler and implement the method ProcessRequest(). The last step is it will call the RemapHandler method which will set the MVCHandler just obtained to be the Current HTTP Handler. public virtual void PostResolveRequestCache(HttpContextBase context) { RouteData routeData = this.RouteCollection.GetRouteData(context); if (routeData != null) { IRouteHandler routeHandler = routeData.RouteHandler; if (routeHandler == null) { throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, SR.GetString("UrlRoutingModule_NoRouteHandler"), new object[0])); } if (!(routeHandler is StopRoutingHandler)) { RequestContext requestContext = new RequestContext(context, routeData); context.Request.RequestContext = requestContext; IHttpHandler httpHandler = routeHandler.GetHttpHandler(requestContext); if (httpHandler == null) { throw new InvalidOperationException(string.Format(CultureInfo.CurrentUICulture,  SR.GetString("UrlRoutingModule_NoHttpHandler"), new object[] { routeHandler.GetType() })); } if (httpHandler is UrlAuthFailureHandler) { if (!FormsAuthenticationModule.FormsAuthRequired) { throw new HttpException(0x191, SR.GetString("Assess_Denied_Description3")); } UrlAuthorizationModule.ReportUrlAuthorizationFailure(HttpContext.Current, this); } else { context.RemapHandler(httpHandler); } } } } Step 4: MVC Handler Executes MVCHandler also inherit from the IHTTPAsyncHandler. When MVC Handler executes it will call the BeginProcessRequest method of the httpAsyncHandler asynchronously. When the process request method is called a new controller gets created. The controller is created from a ControllerFactory. There is a ControllerBuilder Class which will set the ControllerFactory.  You can create your own ControllerFactory as well but by default it will be DefaultControllerFactory. The RequestContext and the name of the Contoller will be passed to the method CreateController Method to get the particular Contoller. public virtual IController CreateController(RequestContext requestContext, string controllerName) { if (requestContext == null) { throw new ArgumentNullException("requestContext"); } if (string.IsNullOrEmpty(controllerName)) { throw new ArgumentException(MvcResources.Common_NullOrEmpty, "controllerName"); } Type controllerType = this.GetControllerType(requestContext, controllerName); return this.GetControllerInstance(requestContext, controllerType); } Next, a ControllerContext object is constructed from the RequestContext and the controller by using the method GetContollerInstance. Finally, the Execute() method is called on the controller class. The ControllerContext is passed to the Execute() method when the Execute() method is called. Step 4: The Controller Executes The Execute() method starts by creating the TempData object. TempData is a dictionary derived from TempDataDictionary class and stored in short lives session and it is a string key and object value.  The Execute() method gets the Action from the RouteData based on the URL.The Controller Class then call the ContollerActionInvoker that builds a list of parameters from the request. These parameters, extracted from the request parameters, will act as method parameters.The parameters will be passed to whatever controller method gets executed. Finally It will call the InvokeAction method to execute the Action. protected override void ExecuteCore() { this.PossiblyLoadTempData(); try { string requiredString = this.RouteData.GetRequiredString("action"); if (!this.ActionInvoker.InvokeAction(base.ControllerContext, requiredString)) { this.HandleUnknownAction(requiredString); } } finally { this.PossiblySaveTempData(); } } public virtual bool InvokeAction(ControllerContext controllerContext, string actionName) { if (controllerContext == null) { throw new ArgumentNullException("controllerContext"); } if (string.IsNullOrEmpty(actionName)) { throw new ArgumentException(MvcResources.Common_NullOrEmpty, "actionName"); } ControllerDescriptor controllerDescriptor = this.GetControllerDescriptor(controllerContext); ActionDescriptor actionDescriptor = this.FindAction(controllerContext, controllerDescriptor, actionName); if (actionDescriptor == null) { return false; } FilterInfo filters = this.GetFilters(controllerContext, actionDescriptor); try { AuthorizationContext context = this.InvokeAuthorizationFilters(controllerContext,  filters.AuthorizationFilters, actionDescriptor); if (context.Result != null) { this.InvokeActionResult(controllerContext, context.Result); } else { if (controllerContext.Controller.ValidateRequest) { ValidateRequest(controllerContext); } IDictionary<string, object> parameterValues = this.GetParameterValues(controllerContext,actionDescriptor); ActionExecutedContext context2 = this.InvokeActionMethodWithFilters(controllerContext,filters.ActionFilters, actionDescriptor, parameterValues); this.InvokeActionResultWithFilters(controllerContext, filters.ResultFilters, context2.Result); } } catch (ThreadAbortException) { throw; } catch (Exception exception) { ExceptionContext context3 = this.InvokeExceptionFilters(controllerContext,filters.ExceptionFilters, exception); if (!context3.ExceptionHandled) { throw; }     this.InvokeActionResult(controllerContext, context3.Result); } return true; } Step 5: The Render View Method is called The Controller typically either executes either the RedirectToAction Method or the RenderView Method. When you call a controller’s RenderView() method,the call is delegated to the current ViewEngine’s RenderView() method.  The WebFormViewEngine.RenderView() method uses a class named the ViewLocator class to find the view. Next, it uses a BuildManager to create an instance of a ViewPage class from its path. Next, if the page has a master page, the location of the master page is set If the page has ViewData, the ViewData is set. Finally, the RenderView() method is called on the ViewPage. The ViewPage class derives from the base System.Web.UI.Page class. This is the same class that is used for pages in classic ASP.NET. The final action that RenderView() method performs is to call ProcessRequest() on the page class. Calling ProcessRequest() generates content from the view in the same way thatcontent is generated from a normal ASP.NET page.

Read More

What are the advantages of ASP.NET MVC

Q.What are the advantages of ASP.NET MVC 
Answer: 
Multi view support
Due to the separation of the model from the view, the user interface can display multiple views of the same data at the same time.

Separation of Concerns
Separation of Concerns is one of the core advantages of ASP.NET MVC .Since code-behind concept has been removed from MVC
The MVC framework provides a clean separate logic for the UI, Business Logic, Model or Data.This feature enable code re-usability.

More Control
The ASP.NET MVC framework provides more control over HTML, JavaScript and CSS than the traditional Web Forms.

Testability Is Easy
ASP.NET MVC framework provides better testability of the Application and good support for the test driven development too.

Lightweight
ASP.NET MVC framework doesn’t use View State and thus reduces the bandwidth of the page.

Read More