.NET framework

GAC stands for Global Assembly Cache.

• It reserves an area for .NET Application to store the assemblies in the memory running on a certain machine.
• It helps in sharing the assemblies to all .NET application.
• To install in GAC, assemblies must have a strong name and must be publicly shared.
• by using Graphical User interface and the command line tool we can work with a cache by installing the CLR which has the global assembly cache and the one with windows shell extensions this is called as Global Assembly Cache tool (Gacutil.exe).
• The .NET Framework provides two tools for working with cache

When we want to share the assembly to the whole application then we use GAC which is stored in the folder of windows directory The concept of GAC is the result of the .NET architecture whose design addresses the issue of "DLL hell" that existed in COM (Component Object Model). In .Net there is no need to register the assembly before taking it in use. We can easily access it globally since it will not conflict by identifying its name, version, architecture, culture and public key

It has a certain feature of a shared library where different users can use the file which is stored in a common folder. In .NET 4.0, its default location is: %windir%\Microsoft.NET\assembly

There are two tools related to GAC are:

1. GAC Tool (gacutil.exe): It is used to check for assembly existence, to register the shared assembly and to view and manipulate GAC contents.
2. Assembly Cache Viewer (shfusion.dll): It helps in displaying the details like version, culture etc. with the assemblies which are associated with it in the cache.

• Dispose: - Dispose helps to release the object resources from the object and not access them again. It basically helps in external memory clean up.it uses the Dispose() method to free up all its expensive resources and making it for reuse, and IDisposable interface is used which decides where and how Dispose() is used.
• Finalize :- If Dispose is not called then Finalize() method is called for the cleanup, when we don’t want to clean up the memory immediately and want to de-allocating the memory later we use Finalization. If Dispose does not call, then garbage collector uses the finalize() method.

The .NET application is said to be multilingual because we can deploy it in different language, the language it supports are visual basics, .NET, C#, J# which compiled to a command Intermediate language the Java byte code which is developed by Microsoft is a low-level language with simple syntax which is easily be translated into native machine code

• CLR:

CLR helps .NET framework to be multilingual, the code running under CLR is termed as managed code, the main task of CLR is to convert compiled code into native code, it has different compilers some of them are

VB .NET, C#, C++, JScript or any third party compiler such as COBOL.

It simply means that you can create pages in different languages (like C#, VB .NET, J# etc.) and once all of these pages are compiled they all can be used in a single application

• CTS:

CTS is Common Type System it is used when we are using the managing types, it is basically used to handle the data types. .NET have many languages and each language is having many other data types one language data types cannot be used in other languages, so in that case, we use the CTS

Example: we have the application in C# which is having the data type of int and there is another data type of integer in VB.NET, them CTS helps in converting the integer into the int32 structure.

• CLS: 

It is Common Language Specification, it has developed certain rules which everyone used to follow like if we have created the code for the multiple inheritances in C++ and if use that code in c# and it will not compile since multiple inheritance is not allowed in C# also it makes C# a case sensitive members of the same class cannot have the same name like Add() and add() they consider as different function.

Expect to come across this, one of the most important dot NET interview questions for experienced professionals in software development, in your next interviews.

When we want to record the unusual activity during runtime, .net takes the help of the trace by following the page execution path which displays the information at run time

There are 2 levels of tracing used in .NET

1. Page Level Tracing
2. Application level Tracing

Page Level Tracing: it is for managing the trace of the page whether it is enabled or disabled, if it is enabled then a page which is requested, it appends to the page a series of tables containing the details of page request during execution

In this there are 2 Trace Modes:

• SortByCategory: In this, it sort trace message according to the categories
• SortByTime: In this, it sorts the message according to the order in which they are processed.

Application Level tracing: In this, we can set the trace for the whole application at once instead of setting for individual page, it is useful when we want to trace for the whole application instead of enabling and disabling for an individual page

We can trace the information according to the request limit we have to specify the default number is 10, as soon as it reaches the request limit it stops tracing.

When an object is created in C#, CLR (normal language runtime) assigns memory for that object from the heap. This procedure is repeated for every newly created variable/object, however, there is a drawback to everything, Memory isn't unrestricted and we have to clean some utilized space so as to prepare for new items. Here, comes the garbage collection is a picture. Garbage Collector manages distribution & recovering of memory. GC makes an outing to the heap and gathers all objects that are no longer utilized by the application and free up the memory.

The Garbage Collection is a significant technique in the .Net framework to free the unused managed code data in the memory. In the Common Language Runtime (CLR), the Garbage Collector acts as an automatic memory manager. It gives the following advantages:

• Empowers you to build up your application without liberating memory.
• Assigns objects to the managed heap efficiently.
• Recovers objects that are never again being utilized, clears their memory and keeps the memory accessible for future allotments.
• Gives memory security by ensuring that an object can't utilize the content of another object.

One of the most frequently posed dot NET interview questions, be ready for this conceptual question.

Certain Garbage Collection ought to be dealt with by the .Net structure. At the point when the object is created then it will be put in the Generation 0. The Garbage Collection utilizes an algorithm which checks the object’s in the age by identifying its current generation number. Once the object’s lifetime is over then it will be expelled from the memory. The two sorts of items. One is Live Objects and Dead Objects. The Garbage Collection algorithm gathers every single unused object that are dead objects in the age. In the event that the live objects running for long time, at that point dependent on that lifetime it will be moved to the next generation.

The object cleaning in the age won't happen precisely after the existence time over of the specific object. At some particular time Garbage Collection starts acting on it & implement its sweeping algorithm to free up the spaces.

There are no particular timings for Garbage Collector to get activated. Garbage Collection happens when one of the accompanying conditions is valid:

• The system has low physical memory. This is recognized by either the low memory warning from the operating system or low memory demonstrated by the host. At the point when an allocation of virtual memory is requested, the virtual memory manager needs to locate a single free block that is enormous enough to fulfill that portion demand. Regardless of whether you have 2 GB of free space, the portion that requires 2 GB will be ineffective except if the majority of that free space is in a single address block.
• The memory that is utilized by allocated objects on the managed heap exceeds an acceptable limit. This limit is continuously balanced as the process runs.
• The GC.Collect method is called. In practically all cases, you don't need to call this technique, in light of the fact that the Garbage Collector runs continuously. This technique is principally utilized for extraordinary circumstances and testing.

a) User sends a solicitation to the IIS

• IIS first checks which ISAPI expansion can serve this solicitation. Contingent upon document augmentation the solicitation is handled.

b) An occasion of the ApplicationManager class is made, which is the Application Domain that the solicitation is handled in.

• As we as a whole know, the application space makes separation between two web applications facilitated on similar IIS. So on the off chance that there is an issue in one application space, it doesn't influence the other application area.

c) In the application space, an occasion of the HostingEnvironment class for example the 'HttpRuntime' object is made, which gives access to data about the application, for example, the name of the organizer where the application is put away.

d) Once the facilitating condition is made, the essential center ASP.NET items like 'HttpContext', 'HttpRequest' and 'HttpResponse' objects are made.

e) The application is begun by making a case of the HttpApplication class. On the off chance that the application has a Global.asax document, ASP.NET rather makes an occasion of the Global.asax class that is gotten from the HttpApplication class.

• HttpApplication cases may be reused for numerous solicitations.

f) Once 'HttpApplication' is made, it begins preparing demands. It experiences following 4 stages:

• (M: HttpModule): Client solicitation handling begins. Before the ASP.NET motor proceeds to make the ASP.NET HttpModule radiate occasions which can be utilized to infuse modified rationale. There are 6 significant occasions that you can use before your page item is made:
  • BeginRequest
  • AuthenticateRequest
  • AuthorizeRequest
  • ResolveRequestCache
  • AcquireRequestState
  • PreRequestHandlerExecute.
• (H: 'HttpHandler'): Once the over 6 occasions are terminated, ASP.NET motor will summon ProcessRequest occasion in the event that you have executed HttpHandler in your task.
• (P: ASP.NET page): Once the HttpHandler rationale executes, the ASP.NET page item is made. While the ASP.NET page item is made, numerous occasions are terminated which can assist us with writing our custom rationale inside those page occasions.
• (M: HttpModule): Once the page article is executed and emptied from memory, HttpModule gives post page execution occasions which can be utilized to infuse custom post-handling rationale. There are 4 significant post-handling occasions PostRequestHandlerExecute, ReleaserequestState, UpdateRequestCache and EndRequest.

This is one of the most frequently asked ASP.NET framework interview questions and answers for freshers in recent times.

• PreInit: This event is raised after the start stage is complete and before the initialization stage.
• Init: This event occurs after all controls have been initialized. We can use this event to read or initialize control properties.
• InitComplete: This event occurs at the end of the page's initialization stage. We can use this event to make changes to view state that we want to make sure are persisted after the next postback.
• PreLoad: This event occurs before the postback data is loaded in the controls.
• Load: This event is raised for the page first time and then recursively for all child controls.
• Control events: This event is used to handle specific control events such as Button control' Click event.
• LoadComplete: This event occurs at the end of the event-handling stage. We can use this event for tasks that require all other controls on the page be loaded.
• PreRender: This event occurs after the page object has created all controls that are required in order to render the page.
• PreRenderComplete: This event occurs after each data bound control whose DataSourceID property is set calls its DataBind method.
• SaveStateComplete: It is raised after view state and control state have been saved for the page and for all controls.
• Render: This is not an event; instead, at this stage of processing, the Page object calls this method on each control.
• Unload: This event raised for each control and then for the page.

State Management is to protect state control in an application in light of the fact that ASP.NET web applications are stateless. Another instance of the Web page class is made each time the page is posted to the server. When a client enters data into a web application, that data would be lost in the round excursion from the program (MSDN).

In a solitary line, State Management keeps up and stores the data of any client till the finish of the client session. There are two types of state management techniques available:

• Client Side
  • Storing data on the client in various ways.
  • Client-Side state management techniques are as follows:
  • View state (used by default by ASP .NET)
  • Control state
  • Hidden fields
  • Cookies
  • Query string
• Server Side
  • Storing data in memory on the server
  • Server-Side state management techniques are as follows:
    • Application state
    • Session state

Client-Side:

• For better scalability by saving user’s data at client-side(browser)
• To support multiple servers, so, when a request is diverted to another server no need to worry about the state.
• To empower the server-side states to be capable to help numerous servers you'll need to utilize techniques like a sticky connection for load balancing.

Server Side

• Pick server-side for better security and to decrease data transfer capacity and website page's size.
• Server side state management is more secure. The state is saved on the server also, consequently isn't conveyed to the client.
• Secret state information shouldn't be utilized with client-side state management
• Server-side diminishes the traffic to and from the user since information isn't sent to the browser and, it's saved on the server.
• Client-side state management technique increases bandwidth usage & therefore application becomes less responsive and you'll experience performance issues.

ASP.NET page has by default EnableViewState property true. This makes ASP.NET consequently monitor the condition of the considerable number of controls present on the page. Presently on the off chance that I am dealing with a web page where I realize every one of the controls will be dynamically bound to certain information on each postback, I don't need to monitor the old data for the controls. So I may choose to turn it off. Presently this is a decent decision however things could get chaotic if a similar page contains a custom control and that custom control is utilizing ViewState to deal with the information inside the control.

So, ASP.NET already provides a technique to handle such scenarios and it's called ControlState.

At whatever point we build up a custom control and need to safeguard some data, we can utilize view state yet assume view state is disabled explicitly by the client, the control won't work as expected. For expected outcomes for the control we need to utilize Control State property. The Control state is isolated from the View state.

The most effective method to utilize control state property, override the OnInit() function for the control and include a call for the Page.RegisterRequiresControlState() function with the instance of the control to register. At that point override LoadControlState and SaveControlState so as to save the required state data.

Hidden field is a control given by ASP.NET which is utilized to store limited quantities of information on the client. It stores one value for a variable and it is an ideal way when the value of that variable is changing regularly. Hidden field control isn't rendered to the browser and is invisible too. A hidden field goes with each request like a standard control's worth.

Let’s see an example of how to use this hidden field. This would increase the value by 1 on every button click.

The source of the hidden field control is:

<asp:HiddenField ID="HiddenField1" runat="server"  /> 

In the code-behind page:

Protected void Page_Load(object sender, EventArgs e)
{
   if (HiddenField1.Value != NULL)
   {
int val = Convert.ToInt32(HiddenField1.Value) + 1;
    HiddenField1.Value = val.ToString();
Label.Text = val.ToString();
   }
}
protected void Button1_Click(object sender, EventArgs e)
{
  //No Action Button Click
}

View state is another client side state management technique in ASP.NET to store client's information, i.e., in some cases the client needs to protect information briefly after a postback, at that point the view state is the favored route for doing it. It stores information in the produced HTML utilizing the hidden field, not on the server.

View State gives page level state management i.e., as long as the client is on the present page, the state is accessible and the client sidetracks to the following page and the present page state is lost. View State can store any sort of information since it is item type yet it is best not to store complex information because of the requirement for serialization and deserilization on each postback. View state is on by default for all server-side controls of ASP.NET with a property EnableviewState set to true.

Let us see with an example how ViewState is utilized & implemented. In the below example we try to save the count of postbacks on each button click.

It’s a tiny file that is being created by the client's browser and also get stored on the hard disk of that client. It doesn't utilize server memory. For the most part, a cookie is utilized to identify users.

A cookie stores client data. At whatever point a client makes a request for a page the first run through, the server creates a cookie and sends it to the client alongside the mentioned page and the client browser gets that cookie and stores it on the client’s either permanently or temporarily. Whenever the client makes a request for a similar site, either the equivalent or another page, the browser checks the presence of the cookie for that site in the folder. In the event that the cookie exists, it sends that request with the same cookie, else that request is treated as a new request. Let see a sample code to understand how it works:

int postbacks = 0; 
if (Request.Cookies["number"] != null) 
{ 
postbacks = Convert.ToInt32(Request.Cookies["number"].Value) + 1; 
} 
// Generating Response 
else  
{ 
postbacks = 1; 
} 
Response.Cookies["number"].Value = postbacks.ToString();
Result.Text = Response.Cookies["number"].Value;

There are two kinds of cookies created by the client’s browser, which are as follows:

• Persistence Cookie: Cookies which has an expiry date time is known as persistence cookies. Persistence cookies are permanently stored until the expiry date time which was set. Let us see how to create persistence cookies. There are two ways to create them:

Link: https://www.codeproject.com/Articles/492397/State-Management-in-ASP-NET-Introduction

• Non-Persistence Cookie: Non-Persistence cookies are not for all time put away on the client customer. It keeps up client data as long as the user accesses the same browser. At the point when the client shuts the browser, the cookie will be disposed of. Non Persistence cookies are helpful for open/public PCs. Let us see how to create non-persistence cookies. There are two ways to create them:

Application state is a server-side state the board procedure. The data put away in the application state is basic for all clients of that specific ASP.NET application and can be accessed from anyplace in the application. It is likewise called the application-level state of the management. Information put away in the application ought to be of little size.

Let’s see how to set & get a value in the application state object:

Following are the Application events on ASP.NET:

There are three events in ASP.NET. The application occasion is written in Global.asax. This document isn't made, of course, it is made expressly by the engineer in the root directory. An application can make more than one Global.asax record yet just the root one is perused by ASP.NET.

• Application_start: The Application_Start event is raised when an application domain begins.
• Application_Error: It is raised when an unhandled exception happens, and we can deal with the exception of this event.
• Application_End: The Application_End event is raised just before an application domain ends as a result of any reason, may IIS server restarting or rolling out certain improvements in an application cycle.

Session Management is a solid system to look after state. By and large session is utilized to store client's data as well as remarkably recognize a client (or state program or browser). The server keeps up the condition of client data by utilizing a session ID. At the point when clients make a request without a session ID, ASP.NET makes a session ID and sends it with each request and response to the same user/client.

Following are the Session Events in ASP.NET:

To deal with a session, ASP.NET gives two events: session_start and session_end that is written in Global.asax in the root directory of the project.

• Session_Start: The Session_start occasion is raised each time another client makes a request without a session ID, i.e., the new program gets to the application, at that point a session_start occasion raised. We should see Global.asax document.
• Session_End: The Session_End event is raised when the session closes either in view of a time out or explicitly by utilizing Session.Abandon(). The Session_End event is brought distinctly up for the situation of In proc mode, not in the state server and SQL Server modes.

There are four session storage mechanisms provided by ASP.NET:

• In Proc mode

In proc mode is the default mode given by ASP.NET. In this mode, session values are put away in the web server's memory (in IIS). On the off chance that there are more than one IIS servers, at that point session values are put away in every server independently on which request has been made. Since the session values are put away in the server, at whatever point server is restarted the session esteems will be lost.

• State Server mode

This mode could store session in the webserver however out of the application pool. Yet, as a rule if this mode is utilized there will be a different server for putting away sessions, i.e., state server. The advantage is that when IIS restarts the session is accessible. It stores sessions in a different Windows service. For State server session mode, we need to design it unequivocally in the web config record and begin the aspnet_state service.

• SQL Server mode

Session is put away in a SQL Server database. This sort of session mode is likewise isolated from IIS, i.e., session is accessible even subsequent to restarting the IIS server. This mode is profoundly secure and dependable yet in addition has a burden that there is overhead from serialization and deserialization of session data. This mode ought to be utilized when reliability is of higher importance than performance of application.

• Custom mode

By and large we ought to lean toward in proc state server mode or SQL Server mode yet on the off chance that you have to store session information utilizing other than these procedures, at that point ASP.NET gives a custom session mode. Thusly we need to keep up everything customized even producing session ID, information store, and furthermore security.

• Session.Clear():
  • Clears all the session values but doesn't destroy the Session.
  • Removes only the values (content) from the Object.
  • The session with the same key is still alive.
  • Use Session.Clear(): if you don’t want to kill the session but just wants to clear the session-specific data and reinitialize the session.
  • It will not raise the Session_OnEnd event.
• Abondon():
  • Destroys the whole session object & release all the resources
  • If you do not call the Abandon method explicitly, the server destroys the objects when the session times out.
  • It has no return value and no parameters
  • Abandon raises the Session_OnEnd event request.
  • If a request is made that includes the session identifier for an expired or abandoned session, a new session is started using the same session identifier

ASP.NET Web Parts is a set of controls for creating Websites that enable users to update the content, behavior and appearance of Web pages directly from a browser. The modifications can be applied to all or individual end-users. When users modify pages or controls, those settings can be saved to retain a user's personal setting preferences across future browser sessions. This feature is called personalization. These Web Parts capabilities mean that developers can authorize end-users to personalize any Web application dynamically, without intervention of any developer or administrator. Different Web Parts can share their data with each other.

Web Parts Modes:

• Normal mode: End users cannot edit & move sections of the page.
• Edit Mode: End users can edit Web Parts & custom properties on the page.
• Design Mode: End users can reorder the pages Web Parts in a WebPartZone.
• Catalog Mode: New Web Parts can be added by the end-user in any WebPartZone on the page.

Utilizing master pages, we can create the common UI components for all the site pages and make a consistent look and feel for the entire site.

• A Master page offers a format/template for at least one or more web forms.
• It characterizes placeholders for the content, which can be superseded by the content pages.
• You would then be able to make individual content pages that contain the content you need to show. At the point when clients demand the content pages, they converge with the master page to create yield that consolidates the format of the master page with the content from the content page
• A Master page has .master as a file extension
• Any Master page is distinguished by an exceptional @Master directive <%@Master Language="C#" %>
• It can have from 1 to many ContentPlaceHolder i.e. can hold multiple content pages

This, along with other NET interview questions for freshers, is a regular feature in NET interviews, be ready to tackle it with the approach mentioned above.

• Page Level: By using the page directive on each content page to bind it to a master page
• Application Level: By making a setting in the pages element of the application's Web.config file. All the specified ASP.NET pages (.aspx files) in the application will be automatically bind to a master page.
• Folder Level: This strategy is used to bind at the application level, except that you make the setting in a Web.config file in one folder only. Here, master-page bindings are applied to all the ASP.NET pages in that folder.

• config:
  • This is automatically installed when you install Visual Studio. Net.
  • This is also called a machine level configuration file.
  • Only one Machine.config file exists on a server.
  • This file is at the highest level in the configuration hierarchy.The settings of Machine.config file are applied to the whole asp.net application.
• config:
  • This is automatically created when you create an ASP.Net web application project.
  • This is also called the application-level configuration file.
  • This file inherits the setting from the Machine.config.
  • Web. Config is used for asp.net web projects/web services.
  • The settings made in the Web.config file are applied to that particular web application only.
• asax:
  • Used to handle application and session-level events and objects for an ASP.NET web site running on an IIS Web Server.
  • Code to handle application events (such as the start and end of an application) resides in Global.asax.
  • Such event code cannot reside in the ASP.NET page or web service code itself, since during the start or end of the application, its code has not yet been loaded (or unloaded).
  • It is also used to declare data that is available across different application requests or across different browser sessions. This process is known as application and session state management

A staple in NET interview questions and answers, be prepared to answer this one using your hands-on experience.

• A Hyperlink just redirects to a given URL identified by "NavigateURL" property.
• Link Button does not have Navigate URL instead it has “Postback URL” property
• LinkButton causes a postback to the same page but it doesn't redirect to a given URL
• HyperLink doesn't have the OnClick event. Link Button has Onclick event
• if you need to do any operation with data that's on the page you will have to use a LinkButton (or a Button), but if you just need to redirect the user to somewhere else go for an HyperLink

This, along with other NET interview questions for freshers, is a regular feature in NET framework interviews, be ready to tackle it with the approach mentioned.

1. Using the FindControl() method

• using System;
• using System.Collections.Generic;
• using System.Linq;
• using System.Web;
• using System.Web.UI;
• using System.Web.UI.WebControls;
• public partial class FindControl : System.Web.UI.Page

{
protected void Page_Load(object sender, EventArgs e)
{
     //Define Label Control and Fetch the control of MASTER PAGE
     Label lbl = (Label)Page.Master.FindControl("lblFirstName");
     //Set the value to CONTENT PAGE label control.
     lblFindControlUserName.Text = "Value Received in Content Page : "+lbl.Text;
}
}

2. Without using the FindControl() method

Yes, by casting the Master to your MasterPage as shown in the below code sample:

protected void Page_Load(object sender, EventArgs e)

{
    MyMasterPage MP = this.Master;
    MP.MyTextBox.Text = "Text Box Found";
}