Free practice test , mock test, driving test, interview questions » .NET

What is WCF – Window Communication Foundation ?

Vinay — Sat, 24 Apr 2010 14:08:11 +0000

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 part of a continuously available service hosted by IIS, or it can be a service hosted in an application

Some useful links

MSDN
Windows Communication Foundation Tutorial

Check out C# interview questions

Creating a dynamic tooltip with AJAX

fanand — Sat, 10 Apr 2010 15:26:10 +0000

The Tooltip is a common graphical user interface element. It is used in conjunction with a cursor, usually a mouse pointer. The User hovers the cursor over an item, without clicking it, and tooltip may appear – a small hoverbox with information about the being hovered over.

Ajax Tool tip : AJAX is the art of exchanging data with a server, and update parts of a web page – without reloading the whole page. By Using the Ajax tool tip we can show the content of the tooltip is retrieved by Ajax from external files.

Files to be used in the Ajax Tool tip
- ajax-tooltip.html = Main HTML file
- js/ajax-tooltip.js = Main JS file for the script
- js/ajax.js = Ajax (SACK library)
- js/ajax-dynamic-content.js = The dynamic content script from this site
- css/ajax-tooltip.css = CSS for tooltip
- images/arrow.gif = Arrow used in the tooltip
- demo-pages = External files loaded by the tooltip

The files used for demo can be downloaded from here http://www.dhtmlgoodies.com/scripts/ajax-tooltip/ajax-tooltip.zip

Configuration : First, you need to include the js files and css files as in the demo (ajax-tooltip.html).

(18)

That’s all we needed to communicate with the server. Now server will obey our instructions and will respond t our requests. Now let’s understand the above code. As I said earlier, core is XMLHttpRequest and it comes in built with the modern browsers.

Line 3 is very simple approach to pass an URL with javascript function loadXMLDoc.

Line 5 detects the browser is being used. There is some tweak, how it behaves with IE7+, Firefox, Chrome, Opera and Safari browser and with IE6 and IE5. Nothing fancy.

Line 7 and 9, create and initializes the XMLHttpRequest object.

Line 13 open() method takes 3 parameters. First one is the type of communication we want to perform with web server. So if you want to get some data from web server, use ‘GET’ else use ‘POST’. Second parameter takes the server URL to whom you want to communicate. The third parameter specifies, if the request should be handled asynchronously. You will stop by and ask, ‘Hey what dose it mean?’. Well, it can have two values. Either true or false. False tells the XMLHttpRequest object to wait until the server request is completed before next statement is executed. For small applications and simple server request, this seems to be ok. But if the request takes a long time or cannot be served, this might cause your web application to hang or stop. Using True, the third parameter, you tell the XMLHttpRequest object to continue the execution after the request to the server has been sent. And since we cannot simply start using the response from the server request before we are sure the request has been completed, we need to set the onreadystatechange property of the XMLHttpRequest, to a function (or name of a function) to be executed after completion. In this onreadystatechange function we test the readyState property before we can use the result of the server call. So, lets make a slight modification to our above code.

Another question, what this readyState is? Well, this property holds the status of the server’s response.

State     Description
0              The request is not initialized
1              The request has been set up
2              The request has been sent
3              The request is in process
4              The request is complete

Now, enough theory. Let’s make a Google suggest kind of stuff and get an understanding, how AJAX works.

AJAX with ASP.NET 4.0 (.NET 4.0 framework is still in beta but a lot to offer)

We are going to use .NET 4.0 framework to show our demo of AJAX using VS.NET 2010 Express (Beta). If you do not have VS.NET 2010 Express (Beta), you can download it from http://msdn.microsoft.com/en-us/vstudio/dd582936.aspx. Remember .NET 4.0 has not been made public yet . Microsoft plans to make it public in March 2010. You can develop this demo in any serve side script you prefer. Since I use .NET, ROR (Ruby on Rails) & PHP for my web development and since now I am playing a lot with new .NET 4.0, I planned to show the demo in VS.NET 2010 Express. Before we start developing our Google suggest demo, I would like to make it clear that we can create AJAX based application in various way and that depends on the technology & IDE you are using. Though we will using VS.NET 2010 (Beta) for our demo, I have taken an approach which will work with all the serve side technologies with little alteration of syntaxes. Let’s design what we will be in need of:

(1)    A request page – default.aspx
(2)    A URL to call which will return the output – search.aspx
(3)    VS.NET inbuilt Sql Server 2005 support to create database file in mdf – GSuggest.mdf
(4)    A table in GSuggest.mdf – Suggestion
(5)    A column in Suggestion table – SuggestionText (nchar(100)
(6)    A LINQ to SQL file – SuggestionDB.dbml

Our pseudo code :-

(1)    Default.aspx is our front page to communicate with web server using AJAX.
(2)    onKeyUp Javascript event of search text box on Default.aspx, calls the search.aspx page via AJAX.
(3)    Search.aspx page process the query using LINQ – SQL and returns back the output string. (Assuming only one output for our demo)
(4)    Default.aspx gets the signal from search.aspx and shows the output as we type in the characters.

Let us start building the our application.

(1) Click Start-> Microsoft Visual Web Developer Express 2010 – ENU

(2) Click File-> New Project

Select “Visual C#” from Installed Templates and “ASP.NET Web Application” as application. Give you project a name (AjaxProject in our case) and choose a location to create a project.

(3) Project will be created. Now right click “App Data” folder -> Add -> New Item

(4) Select “Data” from installed templates and “Sql Server Database”. Give your database a name (GSuggest in our case).

(5) Database created. Now go to “Database Explorer” and browse GSuggest.mdf database. Right click on it and choose “Add New Table”

(6) Create a Column called “SuggestionText” and data type as NCHAR(100). Save this table as “Suggestion”.

(7) Now right click on project -> Add -> New Item.

(8) Select “Data” as installed templates and “LINQ to SQL class” from middle. Give your dbml file name as SuggestionDB.dbml

(9) Drag and drop the Suggestion table from database explorer to SuggestionDB.dbml file

(10)Add following code in your Default.aspx file.

<%@ Page Title=”Home Page” Language=”C#” MasterPageFile=”~/Site.master” AutoEventWireup=”true”
CodeBehind=”Default.aspx.cs” Inherits=”AjaxProject._Default” %>

Welcome to ASP.NET AJAX!

Suggestions:

Above code is very easy to understand. We are taking one input box and one txtHint span. Text box is supposed to take the input from user whereas txtHint span will render the suggestions. Please examine the input box carefully. We have used a javascript function ShowSuggestion which passes input text value id to the function. Now we already know, how to call the server using AJAX. We are taking Search.aspx page as a parameter in open method and one additional “q” parameter. Q is nothing but the parameter name for GET and we pass the input text value. As we type in this Javascript function will be called and it sends its request to search.aspx page with necessary parameter and renders the “Suggestion”.

(11)Now let’s write some code is search.aspx code behind which is suppose feed us the output.

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

namespace AjaxProject
{
public partial class Search : System.Web.UI.Page
{
private SuggestionDBDataContext db = new SuggestionDBDataContext();
protected void Page_Load(object sender, EventArgs e)
{
var sugtext = db.Suggestions;
string suggestion = (from sgText in sugtext
where sgText.SuggestionText.StartsWith(Request.QueryString["q"])
select sgText.SuggestionText).FirstOrDefault();
if (string.IsNullOrEmpty(suggestion))
Response.Write(”No Suggestion Found”);
else
Response.Write(suggestion);
Response.End();
}
}
}

Let’s understand the code above. To access our table Suggestion we created a couple of minutes back, we need to connect to the database and call the Suggestion table and query if it has some data starts with the text entered in the input box (Default.aspx has sent its request). Well, Microsoft is doing enough for developers to reduce the development time. Have you realized that when we created out dbml file and dropped Suggestion table on it, it automatically creates the connection string and saved it into web.config file? Yes, it has. So no need to explicitly define the database connection. We just have to instantiate the context created in dbml file. Since this not a tutorial on ASP.NET, so I will not explain context and other things. It may occupy a whole book if I need to write about it. You can always google around and find. The code will remain same for the developers who are working on VS.NET 2008 (.NET 3.5 framework) . Ok enough theory. Let’s understand our code we just wrote. Since we can write direct SQL code using LINQ to SQL, so we followed the same path. We just accessed the Suggestion table through sugtext and applied LIKE query (StartWith) with our input entered.

(from sgText in sugtext
where sgText.SuggestionText.StartsWith(Request.QueryString["q"])
select sgText.SuggestionText).FirstOrDefault();

Please study the above code very carefully. We just wrote a SQL query using LINQ to SQL and got our Suggestion. Since we may or may not get the suggestion stored in the Suggestion table, so we are checking whether it is null or not.

if (string.IsNullOrEmpty(suggestion))
Response.Write(”No Suggestion Found”);
else
Response.Write(suggestion);
Response.End();

Finally we are returning back the output in our Default.aspx page using Response.Write. You may come across the below screens.

Input matches

Input does not matches

Yes, so simple. In fact we can trace your javascript code in VS.NET 2010 to see the entire process. Just set the breakpoints and run your application.

Microsoft has come up with UI ToolKit called AJAX toolkit. You can navigate this link http://www.codeplex.com/AjaxControlToolkit and can play with it. Using AJAXToolkit you can create a world class web application with very rich user interface.

Future of AJAX

Well, AJAX future is very promising and a lot of web applications are around for which we can feel proud. Social networks web application, corporate intranet applications, interaction with Microsoft Virtual Earth to name a few. I am sure by this time you want to go back and get your hands dirty with AJAX. So what are you waiting for? Go and make rich UI web application with AJAX and learn its true power.

Download the example code

ASP.NET Interview questions

Vinay — Tue, 05 Jan 2010 19:55:57 +0000

If you are going to appear for ASP.Net Interview , make sure you practice out the free tests at Skill-Guru

ASP .Net Interview questions

ASP.Net Chart Control Interview questions

C# Interview questions

And if you are looking for tutorials

ASP .net Tutorial – part 1

ASP .net Tutorial – part 2

State Management in ASP.NET

Arunava — Mon, 04 Jan 2010 17:11:21 +0000

Introduction

For any HTTP based protocol it is true that Web Forms are stateless and for each new request to the web server web pages are destroyed and recreated. As a result we do not get page information beyond the life cycle of a single page. State is the ability of a web application to retain user information and therefore state management becomes an important issue in developing web application.

Objectives

The main objective of this tutorial is to show how the state is managed in ASP.NET Web application. Through this tutorial we have tried to cover:
• State Management and different types of available options in ASP.NET
• Use of Session, Application and Cache variables to manage server state
• Use of Cookies, QueryString, Hidden Field and ViewState to manage client state

State management and its different options

ASP.NET provides state management which saves information within the round trip of page between the server and user’s machine and as a result the information entered by the user can be reused. Please have a look on Figure-1 which clearly shows the difference between state management and without state management.

Figure-1: Difference between ‘Without State Management’ and ‘With State Management’

If state is maintained between pages the information entered originally by an user can be reused in other pages. As shown in Figure-1, user enters his name in Login.aspx page and then the information is sent to the web server so that in the Welcome.aspx page the system can show the same piece of information. But without state management it is not possible.

ASP.NET provides two types of state management, so that information can be maintained between server roundtrips. The types are:

• Server-Side
• Client-Side

User can store state information by using server resources in Server-side management. These options provide higher security than Client-side.

Client-Side state management is simple and has minimal security and does not use server resources to store state information.

Different options are available for both Server -side and Client-side state management. First we discuss on the available options for Server-side state management.

1.Application State:

Application state is a key value dictionary structure that is created during each request to the web pages in a web server. ASP.NET provide instance of HttpApplicationState class for each web application to store the application state.
User can use the Application object to share information among all users of a particular Web application. The Application object is not global to the machine. It is global to HttpApplicaton.

User should prevent the other users or applications to update the Application variables when he/she is modifying it. ASP.NET provides two methods Application.Lock() and Application.UnLock() which can be used to prevent concurrent multiple access of the application variable.

Here we provide a small example about the use of application variables:

Application.Lock(); //Locking the Application variables
Application[“TotalMember”]=int.parse(Application[“TotalMember”].ToString())+1; //Modifying it
Application.UnLock(); //Unlocking the variables

//Retrieving Application variable’s value
LabelCount.Text=”You are member number:“ +Application[“TotalMember “].ToString();

2.Session State with asp.net

In Session state, information is available only to a user of a particular session of a web application. HTTPSessionState class in ASP.NET provides session state. Session state is limited to the current browser session. For example if many users are using a web application then every user will get different session state. This session state is available until the user leaves the application.

Like application state session state is also structured as a key value dictionary structure and it is used to store session specific information which is useful between request for pages and round trip to the web server.ASP.NET provides the session variables that are needed to maintain session state. Generally short lived, sensitive data important for a specific session is stored in session state.

We can identify each active web application session by using a 120 bit Session ID which is formed of ASCII characters and allowed in the URLs.

If a user has not requested a page for more than 20 minutes by default session time out occurs. So if the same user returns back after 20 minutes , he/she will be considered as new user by the web application. But we can modify the session duration in the Web Configuration file. The following is the code in Web.Config file that sets the session duration 30 minutes:

In below we have just written two lines to add and retrieve values from session variables:

Session[“PersonName”]=”Scott”; //Storing name in session variable

Label1.Text=”Welcome Mr.”+ Session[“PersonName”].ToString(); //Retrieving the data

3. The Cache object in asp.net

The Cache object can be used to store information that we can also be stored in application variables. But for each Web Application ASP.NET creates a single Cache object and the items stored in the Cache object cannot be used by other web applications running on the same web server. Thus rather than recreating the value each time, a single cached value can be accessed by any page in the web application.

The Cache object uses key-value pairs to store and retrieve objects. Like dictionary we can add item in a cache object. Here a simple example is shown:

Cache[“PersonName”]=”Scott” ; // Add item in Cache object

Label1.Text=”Welcome Mr.”+ Cache[“PersonName”].ToString(); // Retrieve information from Cache

Like application object Cache object provides automatic lock management on items that are stored in Cache object. As a result users can not modify Cache objects concurrently.

Cache object is made to ensure that the web application does not use server memory much. As a result the Cache object automatically removes the least used items when there is a shortage of server’s memory. Users can set priority on Cache items. So items with higher priority are less likely to be removed from the Cache. The detail on Cache object is out of scope of this tutorial.

Client side state management

Client side state management also has different options to store sate or information. The options are discussed below:

1.Cookies

A cookie is a text file that store small amount of information. The text file is stored on the file system of the client computer or in the memory of client browser session. Generally a cookie contains page specific information and also the information of the domain that issued the cookie.

We can classify cookies in two types:
a.Temporary
b.Persistent

Temporary cookies (non-persistent) exist only in the memory of a browser and as a result information added in temporary cookies are lost when the browser is shut down.

Persistent cookies have a defined expiration period and these type of cookies are stored in user’s hard disk. Users can delete the cookies before the cookie expires. So there is no assurance on the life span of persistent cookies created in user’s machine.

Users should take care of the following things to store information in cookies:

• Cookies can be stolen and faked. So find out different option before storing secured information in cookies.
• Users can not store information more than 4KB in a cookie. So cookie has size restriction.
• Cookies cannot be trusted and users need to cross validate the data retrieved from a cookie.

2. Query Strings

Through query string navigation specific data can be passed and this information is appended to the end of a URL. A typical example might look like the following:

http://abc.com/ItemList.aspx?category=watch&type=ladies

Above in the URL path, the query string starts with the question mark (?) and contains two attribute-value pairs: category and type. Information can be retried from the query string like the following:

Label1.Text=”Items of category ”+Request.QueryString[“category”].ToString()+” are displayed”;

But please remember that query string is the most hackable element on a web site. Users can play with it by changing values and may enter in the restricted pages. A good idea is to return Response.StatusCode=404 when someone changes a URL to an unreasonable value.

3.Hidden Fields

Hidden input fields are sent back as name-value pairs in a Form POST exactly like any other control , except they are not rendered. They are like hidden text boxes. Figure-2 shows a Hidden Field control with the available properties in Visual Studio:

Figure-2: Hidden Field and its Properties

When this control is drag and dropped in the test page the following line is also added in the source section.

Now add a string value in this hidden field as shown in Figure-3:

Figure-3: Add a string value in the Hidden Field

When we run the page we will find the value is added in the HTML code like Figure-4:

Figure-4: HTML code changed for the Hidden Field

4. View State

Web forms provide the ViewState property as a built-in structure for automatically retaining values between multiple requests for same page. ViewState exposes itself as a collection of key/value pairs but renders itself as a hidden field with the name “__VIEWSTATE “ (Shown in Figure-5)

Figure-5: ViewState and its value

View state can store both simple and complex type objects. We can simply add values in ViewState like the following:

ViewState["Name"] = “Scott”;

Note that ViewState value uses only valid ASCII characters to represent all its contents. It is big and appears to be opaque. Viewstate is not acceptable for any kind of sensitive data.

Conclusion

ASP.NET provides lots of functions and utilities (which we discussed in our tutorial above) to store page state in an efficient and effective manner. Choosing among the options will depend on the web application but we should think about the following points before making the choice:
• Amount of information we need to store
• Sensitivity of the information
• Performance expectation from the pages

Web Services with ASP .NET- Part-II

Arunava — Sun, 13 Dec 2009 18:02:20 +0000

This is second part of the tutorial ‘Web Services with ASP.NET’. Please go through Web Services with ASP.NET–Part-I before you continue further.

Consuming a XML Web Service

Exposing data and logic as SOAP to disparate systems across the world becomes simple with the help of ASP.NET. But users are not limited to consuming XML Web services only into ASP.NET application. Web Services can be consumed in Windows forms, mobile applications, databases and more. But here we show the example of how to consume a web service from a .net based web application. Again we are describing the whole process step by step.

1. Create a new Web site by selecting File->New->Web Site from the IDE. When the New Web Site dialog opens , select the ASP.NET Web Site and name it ‘BindWebService’ as shown in Figure-9:

Figure-9: Creating Web Site ‘BindWebService’

2. To consume the web service ‘TestService’ that we have already created right click on the project in the solution explorer of ‘BindWebService’ and select ‘Add Reference’ as shown in Figure-10:

Figure-10: ‘Add Web Reference’ in the project

3. This pulls up the Add Web Reference dialog box as shown in Figure-11

Figure-11: ‘Add Web Reference’ Dialog Box

This dialog box enables users to point to a particular .asmx file to make a reference.

4. Now write down the URL of our created web service and click on ‘GO’. It will automatically find out the proper web service from localhost (as our test web service is in local machine).Now give the Web reference name as ‘MyService’ and then click on ‘Add Reference’ (Figure-12).When any third party wants to use our service he/she needs to mention the proper URL to fetch it (i.e http://abc.com/TestService/Service.asmx where abc.com is the server in which the web service is deployed for hosting)

Figure-12: Adding the proper web reference and rename it accordingly

5. Clicking the ‘Add Reference’ button causes Visual Studio to make an actual reference to the web service and we will find some additional files (web service’s WSDL file) as shown in Figure-13.
The application’s web.config file also contains the reference to the web service in its section.

Figure-13: Web service reference and additional files within solution explorer

6. Now we will show how to utilize web methods in our ‘BindWebService’ application. In the ‘Default.aspx’ page add the code as shown in Figure-14:

Figure-14: Source code for Default.aspx page

Here we take two text boxes in which user will enter two integers and after pressing the ‘ADD’ button the result (called through the web method) will be displayed at the ‘lblResult’ label.

7. Now from the design window double click on the ‘ADD’ button and this will give us the option to write code in the code behind page for the click event of ‘ADD’. The code is given within Figure-15:

Figure-15: Code for Click event of ‘btnAdd’

Here first we check the text boxes are blank or not. If any of them is blank the system will through an error message. Otherwise when the end user clicks the ‘ADD’ button after providing two integers , the application sends a SOAP request to the remote XML web service with the two input values as parameters and gets back a SOAP response containing the result (return value of ‘add’ web method). Proper parsing is required as we are converting string to integer (for arguments) and integer to string (for result).

8. So our application is ready for testing. Press ‘F5’ to run the application. Give two integers as input in the text boxes and press ‘ADD’ which will give you the result. Here we test the application for the values 10 and 15 and get the result 25 (shown in Figure-16)

Figure-16: Desired Output

We do not write code for addition in the code behind page and thus the web method ‘add’ for our previously build web service provide the proper result. Hence we can conclude that our application and the web service is working properly.

Summary

Web Services are an integral part of .Net platform and Visual Studio makes building and consuming web service very easy. This tutorial provides you a simple idea of what is web service and how to build it and access it from .Net based web application. This tutorial focuses on the basic functionalities of web service so that the beginners clearly understand the whole procedure.

Web Services with ASP .NET- Part I

Arunava — Sun, 13 Dec 2009 17:27:29 +0000

Introduction

Web services are a new way of performing remote method calls over HTTP with the use of Simple Object Access Protocol (SOAP) . It becomes very easy for us to use all of this with the help of .Net framework. This tutorial covers building XML Web services and how we can consume XML Web service interfaces and integrate them into ASP.NET applications. But first we examine what is Web service some of the underlying technologies such as SOAP, WSDL and more.

Objective

The main objectives of this tutorial are
a.Give a simple idea about XML web service and the backend technologies.
b.How to build XML web service with the help of Visual Studio 2008
c.How to consume the web service within a web application built in .Net
We will cover the first two portions in Part-I of this tutorial and Part-II will cover the remaining portion.

What is Web Service?

In short we can define Web service as small units of code which is independent of operating system and programming languages and use XML based communicating protocol.

XML is considered ideal for data representation purpose because it enables developers to structure XML documents. But sending self structured XML documents between dissimilar systems cannot solve the purpose. The industry decided on using SOAP (Simple Object Access Protocol) to make the standard XML structure work. SOAP enables user to expose and consume complex data structures such as Datasets or Datatables. So actually ASP.NET Web services generally use SOAP over HTTP using the HTTP post protocol.

WSDL (Web Service Description Language) is another fully XML compliant syntax and specifies Web services by the available methods, the types used by these methods, the request and response message format sent by the methods via protocols like SOAP,HTTP-GET etc. We can say WSDL completely describes Web services, the available methods and the various ways of calling these methods.

Building a Simple XML Web Service

In this tutorial we use Visual Studio 2008 to build an XML Web service. Like our previous tutorial we will provide step by step procedures to create the application:

1.Create a new Web site by selecting File->New->Web Site from the IDE. When the New Web Site dialog opens , select the ASP.NET Web Service and name it ‘TestService’ as shown in Figure-1:

Figure-1: Select ASP.NET Web Service and name it ‘TestService’

2. In the solution explorer there is a single XML Web service named Service.asmx and its code-behind file is located in the App_Code folder (Service.cs).

Figure-2: Files in Solution Explorer

3.Open the Service.asmx file in Visual Studio and you can see the file contains only WebService page directive as shown in Figure-3:

Figure-3: Webservice directive in Service.asmx page

4. Now look at the WebService.cs file—the code behind file for the XML Web. By default a structure of code is already in place in this file. Now we will add a method which we will from our .Net web application in this Web service. Adding a method accessible through the Web service simply requires defining the method as public and giving it ‘WebMethod’ attribute.
Here we will include a function called ‘add’ which will take two integers as arguments and simply returns the added output as result. We will call this function from our .net application Figure-4 shows you the code for that:

Figure-4: ‘add’ function is added

5. Like the ‘WebService’ attribute ‘WebMethod’ can also contain some properties. Some of them are described in short below:
BufferResponse: When it is set to ‘TRUE’ ,the response from the XML web service is held in memory.
CacheDuration: Specifies the life time (in seconds) of the response in system’s cache
Description: Add a description for the WebMethod
EnableSession: ‘TRUE’ enables session state for a method. Default setting is ‘FALSE’

6. Running ‘Service.asmx’ in the browser pulls up the ASP.NET Web service test page. This visual interface is really important for the testing purpose. The page generated for the ‘TestService’ web service is shown in Figure-5:

Figure-5: Exposed web methods for ‘TestService’

The interface shows the name of the Web service in the blue bar with white color at the top of the page. By default the name of the class is used and in this case we have not renamed it. A bulleted list of links to all the Web service’s WebMethods is displayed.

7. A link to the Web Services Description Language (WSDL) document is also available with the link titled ‘Service Description’ in the above figure (Figure-5). Everything we need for the request and the response is described in the WSDL document. Figure-6 shows you the WSDL (just click on the ‘Service Description’ to get the WSDL) for the ‘TestService’:

Figure-6: ‘WSDL’ for ‘TestService’

8. User can test the WebMethod directly from the service.asmx page. Once you click on the ‘add’ method you will find the following screen (Figure-7):

Figure-7: Testing WebMethod directly from the page

As our webmethod ‘add’ requires two input parameters to get a response , we see the two textboxes included in the page. If the webmethod does not require any parameter then there will be only the ‘Invoke’ method.

9. Now put two integers in the two textboxes respectively (as parameter) and click on the ‘Invoke’ button to send SOAP request to the web server. Here we give a=8 b=7 and invoke the method and it will cause a new browser instance with the result to appear (shown in Figure-8)

Figure-8: Expected output

Now we are sure that our webmethod is working properly and we can consume it in an ASP.NET application. This is discussed in Web Services with ASP.NET–Part-II of this tutorial

ASP.Net Chart Control Quiz

Vinay — Wed, 02 Dec 2009 21:06:01 +0000

Arunava is an experienced .NEt developer with very good knowledge of ASP.Net Chart Control. He has added some very good tutorials on

Microsoft Chart Control Tutorial
Advanced features of ASP .Net Chart Control

Recently he created a quiz on ASP .net Chart control Quiz which you will find helpful to test your knowledge on chart controls.

Advanced features of ASP .Net Chart Control

Arunava — Sun, 29 Nov 2009 19:55:18 +0000

This is the second part of .Net chart control and this is going to cover some advanced topic. Please go thorugh Microsoft Chart Control Tutorial before you continue this.

Introduction

In this tutorial we will discuss some advanced features on .Net chart control. As our previous tutorial covers the basics of chart control, we will not discuss those same things over here. Here we focus on the advanced features primarily based on two examples:
1. Creating .Net chart from the data of an XML file
2. Creating .Net chart only by configuring ‘ChartArea’ sectionof the control from the source page
Both of these two examples also show you different features of .Net chart .

Displaying XML data using .Net chart

We are going to mention the steps one by one to create the same things in your machine for practice:

a. First we will add an XML file in our existing project. Right click on the ‘ChartExample’ (the same project created in the last example) in the solution explorer and click ‘Add New Item’ and select ‘XML File’ like Figure-1:

Figure-1: Adding ‘XMLFile.XML’ in the project

b. Add the following data as shown in the snapshot in the XML file:

Figure-2: Data for the XML file

Here we have added the maximum and minimum temperature for a region from the month January to June. Don’t forget to add the ‘’ element otherwise you will encounter an XML exception later.

c. Add another web page in the project and rename it as ‘FromXML.aspx’
d. In the design section drag and drop a Microsoft Chart control from the toolbox.
e. In the code behind page (FromXML.aspx.cs) add the following code within the ‘Page_Load()’ event:

Figure-3: Code within the ‘Page_Load()’ event

Let’s discuss few things about the code mentioned above:
The Dataset gets the XML document using ReadXML() function. You just need to specify the location correctly. Here we will show the maximum and minimum temperature of a region as bar chart. So we need two series with same X axis value within a chart.

We add Series[0] and set the ‘Name’ and ‘temperaturemax’ of each month as X and Y axis value.After that we add another series (‘Series2’) within the same chart and set ‘Name’ and ‘temperaturemin’ of each month as X and Y axis value. Please have a look on Figure-4 and Figure-5 for more clarification.

Figure-4: Binding the first series

Figure-5: Binding the second series

Although data is required for a chart but ‘Title’ is also necessary for better understanding. They can be added in design time as well as at run time. Here we have added title to the chart and the axes (Figure-6 )

Figure-6: Setting the title of the chart and axes

f. Now run the application by setting this as start page you will find the output as shown in Figure-7.

Figure-7: Output with axes and chart title added

g. Sometimes in order to better execution of the details and to reduce the chart size it may be necessary to change the maximum and minimum for the axes. For example the graph shown in Figure-7 has used the default 0 and 50 as minimum and maximum for Y axis. This could be changed by using the maximum and minimum properties of Y axis as shown in Figure-8:

Figure-8: Changing the maximum and minimum for Y axis

Now we will get the chart like Figure-9 on run time

Figure-9: Output with changed minimum and maximum for Y axis

Creating .Net chart by configuring ‘ChartArea’ section

In this example we are going to plot another temperature –month graph but it will be a line graph. Here we will design it totally at design time. Please follow the mentioned steps again to recreate the application

a. Add a new web page in our existing project and rename it as ‘FromChartArea.aspx’
b. In the design section drag and drop a Microsoft Chart control from the toolbox.
c. Here we will build the chart totally at design time.
d. First we will change the default backcolor and height, width of the chart. Change the first line of the chart control from the ‘Source’ window like the following:

e. Now we will add the title and default legend for the graph with the following lines:

<asp:Title Text=”Monthwise Temperature Chart” ForeColor=”Red” />

Titles>

<asp:Legend Name=”DefaultLegend” Docking=”Top” />

Legends>

We can add multiple ‘Title’ and ‘Legend’ for our graph. We will show how the ‘Legend’ appears in a graph later in this example.

f. Now we will add the ‘ChartArea’ object which set up the charting area. This area contains the name of the charting region which is important because a chart can have multiple charting areas and series object.

The ‘InnerPlotPosition’ specifies the region of the charting area to render the chart itself in.

g. In this step we will configure the X and Y axes according to our preference and then close our ‘ChartArea’. Add the following lines now. We will explain the meaning for each line below:

The ‘Title’ beside AxisX and AxisY sets the title for these two axes. We can also set the line color and other properties over here. The ‘LabelStyle’ object specifies settings to use for labels that will be appeared within the chart. The ‘MajorGrid’ specifies whether to draw a line for the major X or Y value and ‘LineWidth’ specifies the width of that line. The chart control automatically determine the major values to draw the grid lines. However we can override this feature to include those lines we prefer.

The .Net chart control provides the control to create custom labels along X and Y axes. We have taken decimal values because the X and Y values are double. So if we specify a value 25 , it may be either 24.9999999999 or 25.0000000001 and both of these is not perfect. That’s why it is good to use a decimal value.

After that we have closed the ‘ChartAreas’ for our chart control

h. Next we will add the ‘Series’ and ‘DataPoints’ in our chart. ‘ Series ‘ refers the reference object and ‘DataPoints’ represent actual data range. Here again we show the maximum and minimum temperature of a region in ‘Line Chart’ format. So we need to add two series (one for maximum and another for minimum)
So just add the mentioned lines to complete the example:

Please note that each series contains the ‘ChartArea’ name in which it will be included. Here we only have one ‘ChartArea’ and the two ‘Series’ point that charting area. Below we are adding the total source code again for your reference:

<%@ Page Language=”C#” AutoEventWireup=”true” CodeFile=”FromChartArea.aspx.cs” Inherits=”FromChartArea” %>

Untitled Page

i. Now run the application by setting ‘FromChartArea.aspx’ as start page and you will find the following output (Figure-10)

Figure-10: Desired output for the Monthwise Temperature Chart

Please have a look in Figure-11 for explanation on the output

Figure-11: Output with proper explanation

Summary

So in the first example we have shown the binding of .Net chart control to XML data. At the same time we have also explored the other chart properties. Chart title and the range of Y axis values are also explored in this example.

In the second example we have shown how the chart control uses ‘Series’ and ‘DataPoints’ to render a chart within a chart region controlled by a ‘ChartArea’ object. This example clearly shows how much control a developer can have over the colors, borders, lines, rendering regions and other styling of the chart.