Top Frequently Asked Questions in .Net Interview

interface TestInterface
{
    void getMethod();
    string getName();
}

abstract class TestAbstractClass
{
    int i = 4;
    int k = 3;
    public abstract void getClassName();
}

interface TestInterface
{
    void getMethod();
    string getName();
}

abstract class TestAbstractClass
{
    protected int i = 4;
    protected int k = 3;

    public TestAbstractClass()
    {
    }

    public abstract void getClassName();
}

interface TestInterface
{
    void getMethod();
    string getName();
}

abstract class TestAbstractClass
{
    public TestAbstractClass()
    {
    }

    int i = 4;
    int k = 3;

    public abstract void getClassName();
}

public interface TestInterface
{
    void getMethod();
    string getName();
}

interface TestInterface
{  
    void getMethod();  
    string getName();  
}

interface Test
{
    void getMethod();
    string getName();
}

string string1 = "Today is " + DateTime.Now.ToString("D") + ".";
Console.WriteLine(string1);

string string2 = "Hi " + "This is Jitendra ";
string2 += "SampathiRao.";
Console.WriteLine(string2);

StringBuilder number = new StringBuilder(10000);
for (int i = 0; i < 1000; i++)
{
    return Number.Append(i.ToString());
}

/* Create two variables that would store the values returned by the fetch statement */

DECLARE @DepartmentName char(25)
DECLARE @DepartmentHead char(25)

/* Define the cursor that can be used to access the records of the table, row by row */

DECLARE curDepartment cursor
for SELECT vDepartmentName, vDepartmentHead from Department

-- Open the cursor

OPEN curDepartment

-- Fetch the rows into variables

FETCH curDepartment into @DepartmentName, @DepartmentHead

-- Start a loop to display all the rows of the cursor

WHILE(@@fetch_status = 0)
BEGIN
    Print 'Department Name =' + @DepartmentName
    Print 'Department Head =' + @DepartmentHead

    -- Fetch the next row from the cursor
    FETCH curDepartment into @DepartmentName, @DepartmentHead
END

-- Close the cursor

CLOSE curDepartment

-- Deallocate the cursor

DEALLOCATE curDepartment  

CREATE TABLE table_name
(
    column_name1 data_type(size) constraint_name,
    column_name2 data_type(size) constraint_name,
    column_name3 data_type(size) constraint_name,
    ....
);

public delegate int DelegateMethod(int x, int y);

public delegate void DelegateExample();

DelegateExample d1 = new DelegateExample(Display);

d1();

using System;

namespace ConsoleApplication5
{
    class Program
    {
        public delegate void delmethod();

        public class P
        {
            public static void display()
            {
                Console.WriteLine("Hello!");
            }

            public static void show()
            {
                Console.WriteLine("Hi!");
            }

            public void print()
            {
                Console.WriteLine("Print");
            }
        }

        static void Main(string[] args)
        {
            // here we have assigned static method show() of class P to delegate delmethod()
            delmethod del1 = P.show;

            // here we have assigned static method display() of class P to delegate delmethod() using new operator
            // you can use both ways to assign the delegate
            delmethod del2 = new delmethod(P.display);

            P obj = new P();

            // here first we have created an instance of class P and assigned the method print() to the delegate i.e. delegate with class
            delmethod del3 = obj.print;

            del1();
            del2();
            del3();
            Console.ReadLine();
        }
    }
}

using System;

namespace delegate_Example4
{
    class Program
    {
        public delegate void delmethod(int x, int y);

        public class TestMultipleDelegate
        {
            public void plus_Method1(int x, int y)
            {
                Console.Write("You are in plus_Method");
                Console.WriteLine(x + y);
            }

            public void subtract_Method2(int x, int y)
            {
                Console.Write("You are in subtract_Method");
                Console.WriteLine(x - y);
            }
        }

        static void Main(string[] args)
        {
            TestMultipleDelegate obj = new TestMultipleDelegate();
            delmethod del = new delmethod(obj.plus_Method1);
            // Here we have multicast
            del += new delmethod(obj.subtract_Method2);
            // plus_Method1 and subtract_Method2 are called
            del(50, 10);

            Console.WriteLine();
            // Here again we have multicast
            del -= new delmethod(obj.plus_Method1);
            // Only subtract_Method2 is called
            del(20, 10);
            Console.ReadLine();
        }
    }
}

using System;

public delegate void Test();

public class Program
{
    static int Main()
    {
        Test Display = delegate()
        {
            Console.WriteLine("Anonymous Delegate method");
        };

        Display();
        return 0;
    }
}

obj.MyEvent += new MyDelegate(obj.Display);

using System;

namespace delegate_custom
{
    class Program
    {
        public delegate void MyDelegate(int a);

        public class XX
        {
            public event MyDelegate MyEvent;

            public void RaiseEvent()
            {
                MyEvent(20);
                Console.WriteLine("Event Raised");
            }

            public void Display(int x)
            {
                Console.WriteLine("Display Method {0}", x);
            }
        }

        static void Main(string[] args)
        {
            XX obj = new XX();
            obj.MyEvent += new MyDelegate(obj.Display);

            obj.RaiseEvent();
            Console.ReadLine();
        }
    }
}

If you run through the following program then it will be much easier to follow.

<add verb="*" path="*.aspx" type="System.Web.UI.PageHandlerFactory"/>

This extension can be associated with the HandlerClass or HandlerFactory class. HttpApplicationobject gets the page object that implements the IHttpHandler Interface. The process of generating the output to the browser is started when the object calls the ProcessRequest method.

Page Life Cycle

Once the HTTP page handler class is fully identified, the ASP.NET runtime calls the handler's ProcessRequest to start the process. This implementation begins by calling the methodFrameworkInitialize(), which builds the control trees for the page. This is a protected and virtual member of the TemplateControl class, the class from which the page itself derives.

Next processRequest() makes the page transition through various phases: initialization, the loading of ViewState and postback data, the loading of the page's user code, and the execution of postback server-side events. Then the page enters into render mode, the ViewState is updated and the HTML is generated and sent to the output console. Finally, the page is unloaded and the request is considered completely served.

Stages and corresponding events in the life cycle of the ASP.NET page cycle.

Stage	Events/Method
Page Initialization	Page_Init
View State Loading	LoadViewState
Postback data processing	LoadPostData
Page Loading	Page_Load
PostBack Change Notification	RaisePostDataChangedEvent
PostBack Event Handling	RaisePostBackEvent
Page Pre-Rendering Phase	Page_PreRender
View State Saving	SaveViewState
Page_Render	Page Rendering
Page_UnLoad	Page Unloading

Some of the events listed above are not visible at the page level. It will be visible if you happen to write server controls and write a class that is derived from the page.

1. PreInit

The entry point of the page life cycle is the pre-initialization phase called "PreInit". This is the only event where programmatic access to master pages and themes is allowed. You can dynamically set the values of master pages and themes in this event. You can also dynamically create controls in this event.

Example. Override the event as given below in your code-behind cs file of your aspx page.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;

public partial class _Default : System.Web.UI.Page
{
    protected void Page_PreInit(object sender, EventArgs e)
    {
        // Use this event for the following:
        // Check the IsPostBack property to determine whether this is the first time the page is being processed.
        // Create or re-create dynamic controls.
        // Set a master page dynamically.
        // Set the Theme property dynamically.
    }
}

2. Init

This event fires after each control has been initialized, each control's UniqueID is set and any skin settings have been applied. You can use this event to change initialization values for controls. The "Init" event is fired first for the bottom control in the hierarchy and then fired up the hierarchy until it is fired for the page itself.

Example. Override the event as given below in your code-behind cs file of your aspx page.

protected void Page_Init(object sender, EventArgs e)
{
    // Raised after all controls have been initialized and any skin settings have been applied.
    // Use this event to read or initialize control properties.
}

3. InitComplete

Raised once all initializations of the page and its controls have been completed. Until now the ViewState values are not yet loaded, hence you can use this event to make changes to the view state that you want to ensure persists after the next postback.

Example. Override the event as given below in your code-behind cs file of your aspx page.

protected void Page_InitComplete(object sender, EventArgs e)
{
    // Raised by the Page object. Use this event for processing tasks that require all initialization to be complete.
}

4. PreLoad

Raised after the page loads the view state for itself and all controls and then processes postback data included with the Request instance.

ViewState data are loaded into controls

Note. The page ViewState is managed by ASP.NET and persists information over a page roundtrip to the server. Viewstate information is saved as a string of name/value pairs and contains information such as control text or value. The ViewState is held in the value property of a hidden control that is passed from page request to page request.

Loads Postback data: postback data are now handed to the page controls.

Note. During this phase of the page creation, form data that was posted to the server (termed postback data in ASP.NET) is processed against each control that requires it. Hence, the page fires the LoadPostData event and parses through the page to find each control and updates the control state with the correct postback data. ASP.NET updates the correct control by matching the control's unique ID with the name/value pair in the NameValueCollection. This is one reason that ASP.NET requires unique IDs for each control on any given page.

Example. Override the event as given below in your code-behind cs file of your aspx page.

protected override void OnPreLoad(EventArgs e)
{
    // Use this event if you need to perform processing on your page or control before the Load event.
    // Before the Page instance raises this event, it loads view state for itself and all controls, and
    // then processes any postback data included with the Request instance.
}

5. Load

The important thing to note about this event is the fact that by now, the page has been restored to its previous state in case of postbacks. Code inside the page load event typically checks for PostBack and then sets control properties appropriately. This method is typically used for most code since this is the first place in the page lifecycle where all values are restored. Most code checks the value of IsPostBack to avoid unnecessarily resetting the state. You may also wish to call Validate and check the value of IsValid in this method. You can also create dynamic controls in this method.

Example: Override the event as given below in your code-behind cs file of your aspx page.

protected void Page_Load(object sender, EventArgs e)
{
    // The Page calls the OnLoad event method on the Page, then re

cursively does the same for each child // control, which does the same for each of its child controls until the page and all controls are loaded. // Use the OnLoad event method to set properties in controls and establish database connections.

6. Control (PostBack) event(s)

ASP.NET now calls any events on the page or its controls that caused the PostBack to occur. This might be a button's click event or a dropdown's selected exchange event, for example.

These are the events, the code for which is written in your code-behind class (.cs file).

Example. Override the event as given below in your code-behind cs file of your aspx page.

protected void Button1_Click(object sender, EventArgs e)
{
    // This is just an example of a control event. Here is the button click event that caused the postback
}

7. LoadComplete

This event signals the end of the Load.

Example. Override the event as given below in your code-behind cs file of your aspx page.

protected void Page_LoadComplete(object sender, EventArgs e)
{
    // Use this event for tasks that require that all other controls on the page be loaded.
}

8. PreRender

Allows final changes to the page or its control. This event takes place after all regular PostBack events have taken place. This event occurs before saving ViewState, so any changes made here are saved.

• For example: After this event, you cannot change any property of a button or change any ViewState value. Because, after this event, the SaveStateComplete and Render events are called.
• Example: Override the event as given below in your code-behind cs file of your aspx page

protected override void OnPreRender(EventArgs e)
{
    // Each data-bound control whose DataSourceID property is set calls its DataBind method.
    // The PreRender event occurs for each control on the page. Use the event to make the final
    // changes to the contents of the page or its controls.
}

9. SaveStateComplete

Prior to this event the view state for the page and its controls is set. Any changes to the page's controls at this point or beyond are ignored.

Example. Override the event as given below in your code-behind cs file of your aspx page.

protected override void OnSaveStateComplete(EventArgs e)
{
    // Before this event occurs, ViewState has been saved for the page and for all controls.
    // Any changes to the page or controls at this point will be ignored.
    // Use this event to perform tasks that require view state to be saved, but that do not make any changes to controls.
}

10. Render

This is a method of the page object and its controls (and not an event). At this point, ASP.NET calls this method on each of the page's controls to get its output. The Render method generates the client-side HTML, Dynamic Hypertext Markup Language (DHTML), and a script that is necessary to properly display a control in the browser.

Note. Right-click on the web page displayed in the client's browser and view the page's source. You will not find any aspx server control in the code. Because all aspx controls are converted to their respective HTML representation. The browser is capable of displaying HTML and client-side scripts

Example. Override the event as given below in your code-behind cs file of your aspx page.

// Render stage goes here. This is not an event

11. UnLoad

This event is used for cleanup code. After the page's HTML is rendered, the objects are disposed of. During this event, you should destroy any objects or references you have created in building the page. At this point, all processing has occurred and it is safe to dispose of any remaining objects, including the Page object.

Cleanup can be performed on,

1. Instances of classes in other words objects
2. Closing opened files
3. Closing database connections.

Example. Override the event as given below in your code-behind cs file of your aspx page

protected void Page_UnLoad(object sender, EventArgs e)
{
    // This event occurs for each control and then for the page. In controls, use this event to do the final cleanup
    // for specific controls, such as closing control-specific database connections.
    // During the unload stage, the page and its controls have been rendered, so you cannot make further
    // changes to the response stream.
    // If you attempt to call a method such as the Response.Write method, the page will throw an exception.
}

10. Request and response in IIS

When the client requests some information from a web server, the request first reaches HTTP.SYS of IIS. HTTP.SYS then sends the request to the respective Application Pool. The Application Pool then forwards the request to the worker process to load the ISAPI Extension that will create an HTTPRuntime Object to process the request via HTTPModule and HTTPHanlder. After that, the ASP.NET Page LifeCycle events start.

12. What are ADO.net objects?

ADO.NET is designed to help developers work efficiently with multi-tier databases, across intranet or internet scenarios.

The ADO.NET object model consists of two key components as follows.

• Connected model (.NET Data Provider: a set of components including the Connection, Command, DataReader, and DataAdapter objects)
• Disconnected model (DataSet).

Connection

1. The Connection object is the first component of ADO.NET. The connection object opens a connection to your data source.
2. All of the configurable aspects of a database connection are represented in the Connection object, which includes ConnectionString and ConnectionTimeout.
3. Connection object helps in accessing and manipulating a database. Database transactions are also dependent upon the Connection object.
4. In ADO.NET the type of Connection is dependent on what database system you are working with.

The following are the most commonly used connections in ADO.NET.

• SqlConnection
• OleDbConnection
• OdbcConnection

Command

1. The Command object is used to perform an action on the data source. The Command object can execute Stored Procedures and T-SQL commands.
2. You can execute SQL queries to return data in a DataSet or a DataReader object. The Command object performs the standard Select, Insert, Delete, and Update T-SQL operations.

DataReader

1. The DataReader is built as a way to retrieve and examine the rows returned in response to your query as quickly as possible.
2. No Data is created; in fact, no more than one row of information from the data source is in memory at a time. This makes the DataReader very efficient at returning large amounts of data.
3. The data returned by a DataReader is always read-only. This class was built to be a lightweight forward-only, read-only, way to run through data quickly (this was called a Firehose cursor in ADO).
4. However, if you need to manipulate a schema or use some advanced display features such as automatic paging then you must use a DataAdapter and DataSet.
5. A DataReader object works in the connected model.

DataAdapter

The DataAdapter takes the results of a database query from a Command object and pushes them into a DataSet using the DataAdapter.Fill() method. Additionally the DataAdapter.Update() method will negotiate any changes to a DataSet back to the original data source.

A DataAdapter object works in a connected model. A DataAdapter performs the following five steps.

1. Create/open the connection
2. Fetch the data as per the command specified
3. Generate XML file of data
4. Fill data into DataSet.
5. Close connection.

Command Builder

It is used to save changes made in an in-memory cache of data on the backend. The work of Command Builder is to generate a Command as per changes in DataRows.

Command Builder generates commands on the basis of row state. There are five-row states.

1. Unchanged
2. Added
3. Deleted
4. Modified
5. Detached

Command Builder works on add, delete, and modify row state only.

Detached is used when an object is not created from the row state.

Transaction

1. The Transaction object is used to execute a backend transaction. Transactions are used to ensure that multiple changes to database rows occur as a single unit of work.
2. The Connection class has a BeginTransaction method that can be used to create a Transaction.
3. A definite best practice is to ensure that transactions are placed in Using statements for rapid cleanup if they are not committed. Otherwise, the objects (and any internal locks that may be needed) will remain active until the GC gets around to cleaning it up.

Parameters

1. A Parameter object is used to solve SQL Injection attack problems while dealing with the user input parameters.
2. A Parameter object allows passing parameters into a Command object. The Parameter class allows you to quickly put parameters into a query without string concatenation.

Note. See my other article on ADO.NET Objects Part II.

Conclusion

Hope the article has helped you to understand ADO.NET objects.

Your feedback and constructive contributions are welcome. Please feel free to contact me for feedback or comments you may have about this article. ADO.NET is designed to help developers work efficiently with multi-tier databases, across intranet or Internet scenarios.

The ADO.NET object model consists of two key components as follows.

• Connected model (.NET Data Provider: a set of components including the Connection, Command, DataReader, and DataAdapter objects)
• Disconnected model (DataSet).

DataSet

1. The DataSet Object is the parent object to most of the other objects in the System. Data namespace. The DataSet is a disconnected, in-memory representation of data.
2. Its primary role is to store a collection of data tables and the relations and constraints between those data tables.
3. DataSet also contains several methods for reading and writing XML, as well as merging other Data Sets, Data Tables, and Data Rows.

Some of the advantages of the new DataSet object are,

• Read / Write
• Connectionless
• Contains one or more DataTable objects with relationships defined in a collection of DataRelation objects
• Supports filtering and sorting
• The contained DataView object can be bound to data-aware form controls
• Supports automatic XML serialization (creation of XML document)

DataTable

1. DataTable stores a table of information, typically retrieved from a data source. DataTable allows you to examine the actual rows of a DataSet through rows and columns collections.
2. Once the DataTable is filled the database connection is released and operates disconnected only.
3. You can complexly bind a control to the information contained in a data table. Controls like DataGrid are used for this purpose.
4. DataTable also stores metatable information such as the primary key and constraints.

DataRows

1. The DataRow class permits you to reference a specific row of data in a DataTable. This is the class that permits you to edit, accept, or reject changes to the individual DataColumns of the row.
2. You would use a DataRow object and its properties and methods to retrieve and evaluate the values in a DataTable object.
3. The DataRowCollection represents the actual DataRow objects that are in the DataTable object, and the DataColumnCollection contains the DataColumn objects that describe the schema of the DataTable object.

DataColumns

1. DataColumns is the building block of the DataTable. A number of such objects make up a table. Each DataColumn object has a DataType property that determines the kind of data that the column is holding. data table.
2. DataColumn instances are also the class of objects that you use to read and write individual columns of a database. The Items property of a DataRow returns a DataColumn.

DataView

1. A DataView is an object that provides a custom view of data in a DataTable. DataViews provides sorting, filtering, and other types of customizations.
2. Each DataTable object has a DefaultView property, that holds the default DataView object for that DataTable. Modifying the DefaultView object sets the default display characteristics for the DataTable.
3. You can create an instance of a DataView and associate it with a specific DataTable in a DataSet. This permits you to have two or more different views of the same DataTable simultaneously available.

DataRelation

A DataRelation identifies that two or more of the DataTables in a DataSet contain data related in a one-to-one or one-to-many (parent-child) association. You define a relationship between two tables by adding a new DataRelation object to the DataSets.

Constraints

Each DataColumn may have multiple Constraints. Conditions such as uniqueness are applied through this class. Constraint objects are maintained through the DataTables Constraints collection.

DataRowView

A DataRowView is a special object that represents a row in a DataView. Each DataView can have a different RowStateFilter, the DataRowView obtained from a DataView will contain data consistent with the DataView's RowStateFilter, providing a custom view of the data.

13. What is the difference between Stored Procedures and functions?

• Procedures can have input/output parameters whereas functions can have only input parameters.
• Procedure allows select as well as DML statements in it whereas a function only allows select statements in it.
• We can go for transaction management in procedures whereas we can't for functions.
• Procedures cannot be utilized in a select statement whereas functions can be embedded in a select statement.

14. What is the difference between Stored Procedures and triggers?

• The Stored Procedures are used for performing tasks
• Stored Procedures are normally used for performing user-specified tasks. It can have the parameters. It can return multiple result sets.
• The Triggers for auditing work
• Triggers normally are used for auditing work. It can be used to trace the activities of the table events.
• The Stored Procedures can have the parameters
• Procedures can have the input and output parameters with all the data types available in the SQL Server as well as user-defined data types.
• The Triggers cannot have any parameters
• Triggers cannot have any parameters.
• Stored Procedure can be run independently
• Stored Procedures can be run independently. They are stored as a database object. It can be called from the application.
• The triggers execute based on table events
• The DML triggers are executed based on the table events defined on the specific table. There are various types of triggers, like DML triggers, DDL triggers (from 2005 onwards), and logon triggers (from 2008 onwards).
• The DDL triggers can control the Stored Procedures creation, drop, and so on.
• The Stored Procedure cannot call triggers
• The Stored Procedures cannot call the triggers directly. But when we do the DML operations on the table, if the corresponding table has the trigger then it will then be triggered.
• The triggers can be called Stored Procedures
• The triggers can be called Stored Procedures.

15. Difference between DataSet and DataReader?

DataReader

DataReader reads data from a database. It only reads using a forward-only connection-oriented architecture during the fetching of the data from the database. A DataReader will fetch the data very fast compared with a DataSet. Generally, we will use an ExecuteReader object to bind data to a DataReader.

To bind DataReader data to a GridView we need to write the code as shown below.

protected void BindGridview()
{
    using (SqlConnection conn = new SqlConnection("Data Source=abc;Integrated Security=true;Initial Catalog=Test"))
    {
        conn.Open();
        SqlCommand cmd = new SqlCommand("Select UserName, First Name, LastName, Location FROM Users", conn);
        SqlDataReader sdr = cmd.ExecuteReader();
        gvUserInfo.DataSource = sdr;
        gvUserInfo.DataBind();
        conn.Close();
    }
}

• Hold the connection open until you are finished (don't forget to close it!).
• It can typically only be iterated over once
• It is not as useful for updating back to the database

DataSet

The data set is a disconnected-oriented architecture. That means that there is no need for active connections to work with DataSets and it is a collection of DataTables and relations between tables. It holds multiple tables with data. You can select data from tables, create views based on tables, and ask child rows over relations. Also, DataSet provides you with rich features like saving data as XML and loading XML data.

protected void BindGridview()
{
    SqlConnection conn = new SqlConnection("Data Source=abc;Integrated Security=true;Initial Catalog=Test");
    conn.Open();
    SqlCommand cmd = new SqlCommand("Select UserName, First Name, LastName, Location FROM Users", conn);
    SqlDataAdapter sda = new SqlDataAdapter(cmd);
    DataSet ds = new DataSet();
    sda.Fill(ds);
    gvUserInfo.DataSource = ds;
    gvUserInfo.DataBind();
}

DataAdapter

A DataAdapter will act as a bridge between a DataSet and the database. This DataAdapter object reads the data from the database and binds that data to a DataSet. DataAdapter is a disconnected-oriented architecture. Check the following sample code to see how to use a DataAdapter in code.

protected void BindGridview()
{
    SqlConnection con = new SqlConnection("Data Source=abc;Integrated Security=true;Initial Catalog=Test");
    con.Open();
    SqlCommand cmd = new SqlCommand("Select UserName, First Name, LastName, Location FROM Users", con);
    SqlDataAdapter sda = new SqlDataAdapter(cmd);
    DataSet ds = new DataSet();
    sda.Fill(ds);
    gvUserInfo.DataSource = ds;
    gvUserInfo.DataBind();
}

• Lets you close the connection as soon it's done loading data, and may even close it for you automatically
• All of the results are available in memory
• You can iterate over it as many times as you need, or even look up a specific record by index
• Has some built-in faculties for updating back to the database.

DataTable

DataTable represents a single table in the database. It has rows and columns. There is not much difference between DataSet and datatable, a DataSet is simply a collection of datatables.

protected void BindGridview()
{
    SqlConnection con = new SqlConnection("Data Source=abc;Integrated Security=true;Initial Catalog=Test");
    con.Open();
    SqlCommand cmd = new SqlCommand("Select UserName, First Name, LastName, Location FROM Users", con);
    SqlDataAdapter sda = new SqlDataAdapter(cmd);
    DataTable dt = new DataTable();
    sda.Fill(dt);
    gridview1.DataSource = dt;
    gridview1.DataBind();
}

16. Difference between JavaScript, jQuery, and AJAX?

JavaScript

1. JavaScript is a client-side (in the browser) scripting language.
2. JavaScript lets you supercharge your HTML with animation, interactivity, and dynamic visual effects
3. JavaScript can make web pages more useful by supplying immediate feedback.
4. JavaScript is the common term for a combination of the ECMAScript programming language plus some means for accessing a web browser's windows and the document object model (DOM).
5. JavaScript was designed to add interactivity to HTML pages.
6. Everyone can use JavaScript without purchasing a license.

jQuery

1. jQuery is a library/framework built with JavaScript.
2. It abstracts away cross-browser compatibility issues and it emphasizes unobtrusive and callback-driven JavaScript programming.
3. jQuery (website) is a JavaScript framework that makes working with the DOM easier by building high-level functionality that can be used to search and interact with the DOM.
4. jQuery implements a high-level interface to do AJAX requests.
5. jQuery is a fast and concise JavaScript Library that simplifies HTML document traversing, event handling, animating, and AJAX interactions for rapid web development

Asynchronous JavaScript XML (AJAX)

1. Asynchronous JavaScript XML (AJAX) is a method to dynamically update parts of the UI without having to reload the page, to make the experience more similar to a Desktop application.
2. AJAX is a technique to do an XMLHttpRequest (out-of-band HTTP request) from a web page to the server and send/retrieve data to be used on the web page.
3. It uses JavaScript to construct an XMLHttpRequest, typically using various techniques on various browsers.
4. AJAX is a set of functions of the language JavaScript.
5. Examples of applications using AJAX: are Google Maps, Gmail, Youtube, and Facebook tabs.

Why AJAX?

This is probably one of the most asked questions about AJAX.

• The main advantage of using AJAX-enabled ASP.NET Web applications is improved efficiency and a reduction of page refresh time. AJAX enables us to refresh only parts of a Web page that have been updated, rather than refreshing the entire page.
• For example, if you have four controls on a web page, say a DropDownList, a TextBox, a ListBox, and a GridView. The GridView control shows some data based on the selection in a DropDownList and other controls. Now let's say a GridView also has paging and sorting options. So whenever you move to the next page or apply a sort, the entire page and all four controls on the page will be refreshed and you will notice a page flicker because ASP.NET must render the entire page on the client-side and it happens once.
• In an AJAX-enabled web page, you will see only the GridView data is being refreshed and the rest of the page and controls do not. Doing so, we not only get better performance and faster refresh, but we also get a better (or should I say "smoother") user experience.
• You may want to see a live example of an AJAX-enabled GridView on our www.mindcracker.com website in the Jobs section here: http://www.mindcracker.com/Jobs/. On this page, if you click on the "Next" page link then you will see only the GridView data is being refreshed. We are also implementing AJAX on C# Corner and other sites as well.

What Browsers Does AJAX Support?

AJAX is JavaScript-based and supports most browsers including Internet Explorer, Mozilla Firefox, and Apple Safari.

What are ASP.NET AJAX Extensions?

ASP.NET AJAX is a combination of client-script libraries (JavaScript) and ASP.NET server components that are integrated to provide a robust development framework.

What are ASP.NET AJAX Server Controls?

The ASP.NET AJAX server controls consist of server and client code that integrate to produce AJAX-like behavior. The following controls are available in the AJAX 1.0 library.

1. ScriptManager: Manages script resources for client components, partial-page rendering, localization, globalization, and custom user scripts. The ScriptManager control is required for the use of the UpdatePanel, UpdateProgress, and Timer controls.
2. UpdatePanel: This enables you to refresh selected parts of the page instead of refreshing the entire page by using asynchronous postback.
3. UpdateProgress: Provides status information about partial-page updates in UpdatePanel controls.
4. Timer: Performs postbacks at defined intervals. You can use the Timer control to post the entire page or use it together with the UpdatePanel control to perform partial-page updates at a defined interval.

What is the ASP.NET AJAX Control Toolkit?

The ASP.NET AJAX Control Toolkit is a collection of samples and components that show you some of the experiences you can create with rich client ASP.NET AJAX controls and extenders. The Control Toolkit provides both samples and a powerful SDK to simplify the creation and reuse of your custom controls and extenders. You can download the ASP.NET AJAX Control Toolkit from the ASP.NET AJAX Web site.

17. What is the difference between WCF and web services?

Web Service in ASP.NET

1. A Web Service is a programmable application logic accessible via standard Web protocols. One of these Web protocols is the Simple Object Access Protocol (SOAP). SOAP is a W3C submitted note (as of May 2000) that uses standards-based technologies (XML for data description and HTTP for transport) to encode and transmit application data.
2. Consumers of a Web Service do not need to know anything about the platform, object model, or programming language used to implement the service; they only need to understand how to send and receive SOAP messages (HTTP and XML).

WCF Service

Windows Communication Foundation (WCF) is a framework for building service-oriented applications. Using WCF, you can send data as asynchronous messages from one service endpoint to another. A service endpoint can be a part of a continuously available service hosted by IIS, or it can be a service hosted in an application. An endpoint can be a client of a service that requests data from a service endpoint. The messages can be as simple as a single character or word sent as XML, or as complex as a stream of binary data.

The following are the scenarios that WCF must be used in.

• A secure service to process business transactions.
• A service that supplies current data to others, such as traffic reports or other monitoring services.
• A chat service that allows two people to communicate or exchange data in real time.
• A dashboard application that polls one or more services for data and presents it in a logical presentation.
• Exposing a workflow implemented using Windows Workflow Foundation as a WCF service.
• A Silverlight application to poll a service for the latest data feeds.

Features of WCF

• Service Orientation
• Interoperability
• Multiple Message Patterns
• Service Metadata
• Data Contracts
• Security
• Multiple Transports and Encoding
• Reliable and Queued Messages
• Durable Messages
• Transactions
• AJAX and REST Support
• Extensibility

Difference between a Web Service in ASP.NET & WCF Service

1. WCF is a replacement for all earlier web service technologies from Microsoft. It also does much more than what is traditionally considered as "web services".
2. WCF "web services" are part of a much broader spectrum of remote communication enabled through WCF. You will get a much higher degree of flexibility and portability doing things in WCF than through traditional ASMX because WCF is designed, from the ground up, to summarize all of the various distributed programming infrastructures offered by Microsoft. An endpoint in WCF can be communicated with just as easily over SOAP/XML as it can over TCP/binary and to change this medium is simply a configuration file modification. In theory, this reduces the amount of new code needed when porting or changing business needs, targets, and so on.
3. ASMX is older than WCF, and anything ASMX can do so can WCF (and more). Basically, you can see WCF as trying to logically group together all the various ways of getting two apps to communicate in the world of Microsoft; ASMX was just one of these many ways and so is now grouped under the WCF umbrella of capabilities.
4. Web Services can be accessed only over HTTP & it works in a stateless environment, whereas WCF is flexible because its services can be hosted in various types of applications. Common scenarios for hosting WCF services are IIS, WAS, Self-hosting, and Managed Windows Service.
5. The major difference is that Web Services use XmlSerializer. But WCF uses DataContractSerializer which is better in performance than XmlSerializer.

Key issues with XmlSerializer to serialize .NET types to XML are,

• Only Public fields or Properties of .NET types can be translated into XML
• Only the classes that implement the IEnumerable interface
• Classes that implement the IDictionary interface, such as the Hash table cannot be serialized

Some important differences between DataContractSerializer and XMLSerializer are,

• A practical benefit of the design of the DataContractSerializer is better performance overXmlserializer.
• XML Serialization does not indicate which fields or properties of the type are serialized into XML whereasDataCotractSerializer
• Explicitly shows which fields or properties are serialized into XML
• The DataContractSerializer can translate the HashTable into XML

Using the Code

The development of a web service with ASP.NET relies on defining data and relies on the XmlSerializer to transform data to or from a service.

Key issues with XmlSerializer to serialize .NET types to XML.

• Only Public fields or Properties of .NET types can be translated into XML
• Only the classes that implement the IEnumerable interface
• Classes that implement the IDictionary interface, such as the Hash table cannot be serialized

The WCF uses the DataContractAttribute and DataMemeberAttribute to translate .NET FW types into XML.

using System.Runtime.Serialization;

[DataContract]
public class Item
{
    [DataMember]
    public string ItemID;

    [DataMember]
    public decimal ItemQuantity;

    [DataMember]
    public decimal ItemPrice;
}

The DataContractAttribute can be applied to the class or a structure. DataMemberAttribute can be applied to a field or a property and these fields or properties can be either public or private.

Some important differences between DataContractSerializer and XMLSerializer are.

• A practical benefit of the design of the DataContractSerializer is better performance over XML serialization.
• XML Serialization does not indicate which fields or properties of the type are serialized into XML whereas DataContractSerializer explicitly shows which fields or properties are serialized into XML.
• The DataContractSerializer can translate the HashTable into XML.

Developing Service

To develop a service using ASP.NET, we must add the WebService attribute to the class and WebMethodAttribute to any of the class methods.

Example

using System.Web.Services;

[WebService]
public class Service : System.Web.Services.WebService
{
    [WebMethod]
    public string Test(string strMsg)
    {
        return strMsg;
    }
}

To develop a service in WCF, we will write the following code.

[ServiceContract]
public interface ITest
{
    [OperationContract]
    string ShowMessage(string strMsg);
}

public class Service : ITest
{
    public string ShowMessage(string strMsg)
    {
        return strMsg;
    }
}

The ServiceContractAttribute specifies that an interface defines a WCF service contract,

OperationContract attribute indicates which of the methods of the interface defines the operations of the service contract.

A class that implements the service contract is referred to as a service type in WCF.

Hosting the Service

ASP.NET web services are compiled into a class library assembly and a service file with an extension .asmx will have the code for the service. The service file is copied into the root of the ASP.NET application and Assembly will be copied to the bin directory. The application is accessible using the URL of the service file.

WCF Service can be hosted within IIS or WindowsActivationService as in the following.

• Compile the service type into a class library
• Copy the service file with an extension.SVC into a virtual directory and assembly into the bin subdirectory of the virtual directory.
• Copy the web. config file into the virtual directory.

Client Development

• Clients for the ASP.NET Web services are generated using the command-line tool WSDL.EXE.
• WCF uses the ServiceMetadata tool (svcutil.exe) to generate the client for the service.

Message Representation

• The Header of the SOAP Message can be customized in ASP.NET Web service.
• WCF provides attributes MessageContractAttribute, MessageHeaderAttribute andMessageBodyMemberAttribute to describe the structure of the SOAP Message.

Service Description

• Issuing an HTTP GET Request with query WSDL causes ASP.NET to generate WSDL to describe the service. It returns the WSDL as a response to the request.
• The generated WSDL can be customized by deriving the class of ServiceDescriptionFormatExtension.
• Issuing a Request with the query WSDL for the .svc file generates the WSDL. The WSDL generated by WCF can be customized by using the ServiceMetadataBehavior class.

Exception Handling

In ASP.NET Web services, unhandled exceptions are returned to the client as SOAP faults.

In WCF Services, unhandled exceptions are not returned to clients as SOAP faults. A configuration setting is provided to have the unhandled exceptions returned to clients for the purpose of debugging.

18. SOAP, WSDL, UDDI Overview

• XML: Describes only data. So, any application that understands XML, regardless of the application's programming language or platform, has the ability to format XML in a variety of ways (well-formed or valid).
• SOAP: Provides a communication mechanism between services and applications.
• WSDL: Offers a uniform method of describing web services to other programs.
• UDDI: Enables the creation of searchable Web services registries

Note. Some Contents are copied from various Interview Websites.