ASP.NET, C# and .NET

Calling web service using javascript. Part - 2

2010-04-20T20:20:00.001+05:30

In the first part of the blog we saw how to invoke web methods using javascript. In this blog we will take a look at how to invoke web service methods using Webservice behavior (HTC file). WebService behavior is a component which helps in invoking web service methods using SOAP protocol. The HTC file can be freely downloaded from Microsoft’ site. By default HTC file support asynchronous invocation of web service methods. One can enable synchronous way of invocation as well, but do keep in mind that synchronous invocation can freeze the screen (browser) till the web method execution is completed, which may not be desired in web application.

Making use of WebService behavior (HTC file)

To make use of WebService behavior to invoke web service methods we need to download webservice.htc file from here. Once you have downloaded the HTC file save it in any folder in your website. Once the “webservice.htc” file has been downloaded and saved in your application the next thing is to hook up the “htc” file to any of the html control using the style attribute. Once you have attached the “htc” file to a control then you can use the various methods in the “htc” file to invoke web service methods. Sample javascript code and web service is pasted below.

<body>
<script language="javascript" type="text/javascript">
function callWebService()
{
     var webSer = document.getElementById("webServiceHTC");
     webSer.useService(“http://localhost:3150/TestService.asmx?wsdl”, "ServiceTest");
     var uniqueID = webSer.ServiceTest.callService(handleResult, "HelloWorld");
}
function handleResult(result)
{
    alert(result.value);
}
</script>
<form id="form1" runat="server">
    <input type=”text” id="webServiceHTC" style="behavior:url(htc/webservice.htc)"/>
    <asp:Button ID="javascripWSInvoke" runat="server" Text="Invoke" OnClientClick="javascript:callWebService(); return false;" />
</form>
</body>

//Web service method

[WebMethod]
public string HelloWorld()
{
return "Hello World";
}

In the code pasted above, we are attaching the “webservice.htc” file using the html “style” property of an html control. Once the “webservice.htc” file is attached to a html control you can access the “htc” file by retrieving the control using the “getElementById” javascript method. As you can see, from the above code, we are retrieving the textbox control using the “getElementById” method and we are making use of the “useService” method defined in the “webservice.htc” file. Using the “useService” method one can register a web service and give it a friendly name. The method takes two arguments, first is the url of the web service and the second is the friendly name. The friendly name is then used along with the control to invoke web service methods, as pasted in the above code, where we are using the friendly name along with “callService” method to invoke web method. “callService” method has optional first argument which is the name of the javascript function which will handle the result returned from the web method, second argument is the name of the web method which needs to be invoked and then list of parameters separated by comma.

“handleResult” method handles the result returned from the web service method. The method takes an argument which will hold the value returned from the web service method. In the “handleResult” we are showing the output in a alert message. The result argument will have four properties namely “error”, “id”, “raw” and “value”. “error” is a boolean value which indicates whether there was any error, “id” holds the unique id returned while invoking the web method, “raw” will have the raw XML and “value” will have the actual value returned from the web service method. “value” property can have simple as well as complex objects.

Passing parameters to a web method.

The above sample was a simple web method invocation without parameters. Now, lets see how to pass parameters to a web method.

function passParameter()
{
        //Getting the htc file attached object.
        var txtCntl = document.getElementById("divHTC");
        //Assigning the web service url.
        txtCntl.useService("http://localhost:3150/TestService.asmx?wsdl", "webServ");
        //Variables to pass as arguments to the web method.
        var fName = "Sandeep";
        var lName = "P R";
        var mName = "";
        //Invoking the "CombineName" web method.
        var uniqueID = txtCntl.webServ.callService(handleResult, "CombineName", fName, mName, lName);
}

The above code is pretty much the same as the one we have previously used to invoke a web method. The only difference here is that we are passing arguments as a comma separated list to “callService” method. As explained before the first two arguments of “callService” method take the name of the javascript function which handles the response and second argument is the name of the web method to be invoked. The next set of arguments starting from the third arguments are the parameters which needs to be passed to the web method. You can pass any number of arguments separated by comma. Once the web method returns the output the control is passed to “handleResult” javascript method which does nothing other than elegantly showing output in a alert box.

Lets see the code for the web method invoked in the above javascript method.

[WebMethod]
public string CombineName(string firstName, string midleName, string lastName)
{
return string.Concat(string.Concat(firstName, " - ", midleName), " - ", lastName);
}

The above web method is pretty straight forward. It concatenates all the arguments passed into it and returns it as a single string.

Sending complex objects to a web method

We have invoked web method without parameter, with parameters and next is what? Obviously, passing complex objects to a web service method. It is very much possible to pass complex objects to a web method using web service behavior. Below seeing the javascript code in action lets see the code for the web service method and complex object which forms the method argument.

//Web service method which takes complex object "Car" as an argument.
[WebMethod]
public string GetCar(Car car)
{
return "Model: " + car.Model + ", Cubic capacity: " + car.CC + ", Color: " + car.Color;
}

//The "Car" class.
public class Car
{
    public string Model
    {
         get;
         set;
    }

    public int CC
    {
         get;
         set;
    }

    public string Color
    {
         get;
         set;
    }
}

The above web method is pretty straight forward, it takes a complex object (Car) as one of its argument and concatenates all the properties of the “Car” class and returns it as a string. Now lets see how to pass the complex “Car” object to the web method using javascript and webservice behavior.

//Javascript method which sends complex "Car" object as an argument to web service method.
function sendComplexObject()
{
    var ccar = new Object();
    ccar.Model = "Ferrari";
    ccar.CC = 2345;
    ccar.Color = "Ferrari Red";
    ccar.Blah = "dlkjs";
    var txtCntl = document.getElementById("divHTC");
    txtCntl.useService("http://localhost:3150/TestService.asmx?wsdl", "webServ");
    var uniqueID = txtCntl.webServ.callService(handleResult, "GetCar", ccar);
}
//Method which handles the response.
function handleResult(result)
{
    alert(result.value);
}

In the above “sendComplexObject” javascript function we are first creating a javascript object of type “Object”. Once the object of type “Object” is created, we are dynamically adding properties to the object. One thing to note here is that the dynamically added properties should have the same name as that of the server side object properties and it is case sensitive. If you closely notice the above code we have added an extra property called “Blah” to the “Car” object. Now, you may be thinking how is this object of “Object” type getting converted to a strongly typed .NET object. When the web method is invoked using “callService” method, the HTC file has got the necessary code to read the schema and infer the type of argument the method takes and converts the properties into a XML and sends to the web service method. In the web service side the .NET runtime takes care of serializing the XML to respective .NET object. We have added an additional “Blah” property to the object which during serialization is not converted as there is no corresponding server side property.

Note: If you have any value type in your complex object (like “CC” property in the “Car” object) then make sure that you assign them a value (default) even if you are not going to use it in the server side, else while invoking the web method the server can throw “System.FormatException”. The details of the exception which was thrown while not assigning the “CC” property of the “Car” object is pasted below.

System.Web.Services.Protocols.SoapException: Server was unable to read request. ---> System.InvalidOperationException: There is an error in XML document (7, 22). ---> System.FormatException: Input string was not in a correct format.
   at System.Number.StringToNumber(String str, NumberStyles options, NumberBuffer& number, NumberFormatInfo info, Boolean parseDecimal)
   at System.Number.ParseInt32(String s, NumberStyles style, NumberFormatInfo info)
   at System.Xml.XmlConvert.ToInt32(String s)
   at Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationReader1.Read3_Car(Boolean isNullable, Boolean checkType)
   at Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationReader1.Read8_GetCar()
   at Microsoft.Xml.Serialization.GeneratedAssembly.ArrayOfObjectSerializer8.Deserialize(XmlSerializationReader reader)
   at System.Xml.Serialization.XmlSerializer.Deserialize(XmlReader xmlReader, String encodingStyle, XmlDeserializationEvents events)
   --- End of inner exception stack trace ---
   at System.Xml.Serialization.XmlSerializer.Deserialize(XmlReader xmlReader, String encodingStyle, XmlDeserializationEvents events)
   at System.Xml.Serialization.XmlSerializer.Deserialize(XmlReader xmlReader, String encodingStyle)
   at System.Web.Services.Protocols.SoapServerProtocol.ReadParameters()
   --- End of inner exception stack trace ---
   at System.Web.Services.Protocols.SoapServerProtocol.ReadParameters()
   at System.Web.Services.Protocols.WebServiceHandler.CoreProcessRequest()

How to handle complex objects returned from the server?

There can be scenarios where the server may return complex objects back to the caller. How to handle complex objects in javascript? Don’t worry with HTC file that is also a child’ play. Below is a web method which returns a complex “Car” object. We have slightly altered the “Car” class.

//Method that returns a complex Car object.
[WebMethod]
public Car GetCarObject()
{
return new Car { Model = "Ferrari", Color = "Ferrari Red", CarEngine = new Engine { CC = 2500, Cylinders = 8 } };
}

//Car class.
public class Car
{
   public string Model
   {   get; set; }
   public string Color
   { get; set; }
   public Engine CarEngine
   { get; set; }
}
//Engine class which is a property in Car class
public class Engine
{
   public int CC
   { get; set; }
   public int Cylinders
   { get; set; }
}

In the web method we are creating an instance of the “Car” class and returning it. The “Car” class is quite simple, it has a number of properties and in those properties one of the property is again a complex object of type “Engine”. Below is the javascript code which handles the complex object returned from the web service.

function receiveComplexObject()
{
    var txtCntl = document.getElementById("divHTC");
    txtCntl.useService("http://localhost:3150/TestService.asmx?wsdl", "webServ");
    var uniqueID = txtCntl.webServ.callService(handleComplexObject, "GetCarObject");
}
//Function handling the complex object.
function handleComplexObject(result)
{
    var carObj = result.value;
    var carProperties = "Model: " + carObj.model + ", Color: " + carObj.Color + ", CarEngine.CC: " + carObj.CarEngine.CC + ", CarEngine.Cylinders: "
                                + carObj.CarEngine.Cylinders;
    alert(carProperties);
}

“handleComplexObject” function handles the complex “Car” object returned from the server. The “value” property of the result object holds the complex object. You can access the various properties and fields in a complex object by specifying the names of the properties or fields as done in the above e.g.

How to handle server errors in client Side?

We have seen the different ways of invoking a web method with parameters, without parameters and with complex parameters. As we all know everything doesn’t work according our plan, so what happens if the server throws an error? Handling errors from server is also pretty much simple.The method which is specified in “callService” method to handle the result takes an argument. The result object passed as an argument to the callback function which handles the request from the service has got the necessary information to handle errors. Lets see with e.g.

//Javascript function which is supposed to throw error.
function sendComplexObject()
{
    var ccar = new Object();
    ccar.Model = "Ferrari";
    ccar.Color = "Ferrari Red";
    var txtCntl = document.getElementById("divHTC");
    txtCntl.useService("http://localhost:3150/TestService.asmx?wsdl", "webServ");
    var uniqueID = txtCntl.webServ.callService(handleError, "GetCar", ccar);
}
//Function which handles server side error.
function handleError(result)
{
    if (result.error)
    {
        var errorDetails = "Error code: " + result.errorDetail.code;
        errorDetails += "\nError string: " + result.errorDetail.string;
        errorDetails += "\nError soap format: " + result.errorDetail.raw.xml;
        alert(errorDetails);
    }
    else
    {
       alert(result.value);
    }
}

The above pasted code is pretty straight forward. The “handleError” function like other callback function in this blog takes a result object as argument. The first line of the function checks whether there is any error in the result returned from the server by checking the “error” property of the result object. If there is an error the next three lines of code retrieve the error details by accessing the “errorDetail” property’ “code”, “string” and “raw.xml” properties. The code property returns the code for the error, “string” property returns the error message and “raw.xml” returns the whole SOAP xml.

So that’ some of the key features of webservice behavior. In the next blog we will see how to make use of “ScriptManager” to invoke web methods. Till then try to know more.

Sandeep

Calling web service using javascript. Part - 1

2010-03-15T23:14:00.000+05:30

Many a times there was this pressing need where I had to call a web service method and get the output and use it in javascript. There were many options available like making use of javascript to call web service method or using some third party javascript library or by making use of webservice behavior (HTML Component (HTC) file) or making use of AJAX and calling an ASPX page which in turn calls a webservice in the code behind and returns the output as XML or if you are using ASP.NET 2.0 then you can make use of “ScriptManager”. We will see all the above ways of invoking a webservice one by one except making use of third party javascript library. As there are many third party javascript libraries available in the internet so we will not concentrate on any as each have different ways of implementation. Lets see each of the methods in action one by one.

Using javascript to invoke web service methods

One of the simplest and easiest way is to invoke web service methods is by making use of “XMLHttpRequest” objects in javascript. Before invoking the web service method using javascript lets see the web service methods which we are going to be invoked using javascript. Below are two sample methods which we are going to be invoked using javascript.

public class TestService : System.Web.Services.WebService
{
        [WebMethod]
        public string HelloWorld()
        {
            return "Hello World";
        }
        [WebMethod]
        public string CombineName(string firstName, string midleName, string lastName)
        {
            return string.Concat(string.Concat(firstName, " - ", midleName), " - ", lastName);
        }
}

The above two methods are pretty straight forward, one returns a string and the other takes three string arguments and combines them and returns as a string. We will see how to call a web service method without parameters and with parameters. Lets first see how to call the “HelloWorld” web method which doesn’t take any parameter. Below is the javascript code for invoking the “HelloWorld” web method.

function webServiceCallWithoutParameters()
{
        var xmlHttpReq = new XMLHttpRequest();
        xmlHttpReq.open("POST", "http://localhost/TestService.asmx/HelloWorld", false);
        xmlHttpReq.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
        xmlHttpReq.send();
        alert(xmlHttpReq.responseXML.childNodes[1].text);
}

In the above javascript function we are making use of “XMLHttpRequest” object to invoke web service method. We are making use of the “open” method which takes three arguments, first argument says whether the method used is “POST” or “GET”, second argument is the url for the web service and the third argument is to specify whether the “XMLHttpRequest” should be synchronous or asynchronous. The url for a .NET web method always ends with the name of the web method preceded by the url of the web service as shown in the above e.g. Once we have set the url and the method used to call the web service, in the next line we are setting the “Content-Type” for the request using the “setReqeustHeader” method of the “XMLHttpReqeust” object. Its very important to set the “Content-Type” of the request to “application/x-www-form-urlencoded” when you are trying to invoke a web service method, if the “Content-Type” is not set to “application/x-www-form-urlencoded” the following error will be thrown when you try to pass arguments to a web service method.

status: 500
statusText: Internal Server Error
responseText: System.InvalidOperationException: Request format is invalid: . at System.Web.Services.Protocols.HttpServerProtocol.ReadParameters() at System.Web.Services.Protocols.WebServiceHandler.CoreProcessRequest()

The status property of the “XMLHttpReqeust” object will have a value of 500, the “statusText” will be having “Internal Server Error” as the message and the “responseText” will have the type of error. To solve the problem set the “Content-Type” for the request as shown in the above e.g.

Now let’ see how to pass parameters to a web method.

var xmlHttpReq = new XMLHttpRequest();
xmlHttpReq.open("POST", "http://localhost:3150/TestService.asmx/CombineName", false);
xmlHttpReq.setRequestHeader("Content-Type","application/x-www-form-urlencoded");
xmlHttpReq.send("firstName=Sandeep&midleName=mid&lastName=p r");
alert(xmlHttpReq.responseXML);

In the above javascript function we are invoking the “CombineName” web method which takes three parameters. Everything else is the same as the previous javascript function except for the “send” method of the “XMLHttpReqeust” object. In the “send” method we are passing the parameters separated by the ampersand (&) symbol. To pass parameter to a web method you can use the “send” method of the “XMLHttpRequest” object. The parameters and their values should be separated by the “equal to” (=) symbol and each set of parameters should be separated by the ampersand symbol.

After this the next obvious question would be how to send complex objects to a web methods. There is no straight forward way of doing this, one can make use of Javascript Object Notations (JSON). You can find lots of e.g. on how to pass JSON over the net. Also you can use “WebService” behavior (HTC file) to send and receive complex objects or one can use “ScriptManager” to send and receive complex objects. We will see “HTC file” and “ScriptManager” usage in subsequent blogs. Receiving a complex object is pretty easy. When you invoke a web method and if that web method returns a complex object then the object will be serialized into a XML and the XML can be accessed through the “responseText” or “responseXML” property of the “XMLHttpRequest” object. Lets see with an e.g. Below is the web method code which returns a “Car” complex object.

[WebMethod]
public Car GetCarObject()
{
return new Car { Model = "Ferrari", Color = "Ferrari Red", CC = 2555 };
}

//Car Class is pasted below.

public class Car
{
    public string Model
    {
        get;   set;
    }
    public int CC
    {
        get;   set;
    }
    public string Color
    {
        get;   set;
    }
}

The above web method is pretty straight forward. It creates an instance of a “Car” class and returns the same. The “Car” class is also pasted. The javascript method to invoke the above web method which returns “Car” complex object is pasted below.

function getComplexObject()
{
    var xmlHttpReq = new XMLHttpRequest();
    xmlHttpReq.open("POST", "http://localhost:3150/TestService.asmx/GetCarObject", false);
    xmlHttpReq.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
    xmlHttpReq.send();
    alert(xmlHttpReq.responseText);
}

The output returned in the form of the XML is pasted below.

<?xml version="1.0" encoding="utf-8"?>
<Car xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns="http://tempuri.org/">
<Model>Ferrari</Model>
<CC>2555</CC>
<Color>Ferrari Red</Color>
</Car>

As you can see in the above XML the complex object returned by the web method is serialized as XML. That's about invoking web methods using javascript. In my next blog we will see how to invoke web methods using “WebService behviour” or by using “HTC file”. Till then try to know more.

Sandeep

Visual Studio 2010 features preview.

2010-02-28T21:38:00.001+05:30

Today I got an opportunity to attend the “Visual Studio 2010 Pit stop” in Chennai. If I am not wrong it is a pre launch event which Microsoft is conducting in different cities to generate interest and gauge developers reaction on the various features which is getting introduced in VS 2010. I thought why not blog on some of the features which were demoed.

With the release of VS 2010 Microsoft is trying to make Visual Studio capable of managing all the phases of Application Lifecycle Management (ALM). They want VS 2010 to target developers, architects and testers. Lets see what VS 2010 brings to the table for different audience it targets.

For developers

The first feature which was demoed was simple yet powerful, which was targeted towards developers like me, who hate to drag and drop controls from the toolbox instead prefer writing the controls in HTML view. The feature is a kind of auto complete whereby when in the HTML view of an aspx page you need to type the name of the control and from the intellisense one need to select the control and press tab and VS 2010 will add the full tag with ID, Text and other properties. Though the beta release of VS 2010 which was used for the demo didn’t auto generate ID and other properties, it only auto generated “Text” property, but it was promised that the production version would generate most of the relevant properties like ID etc.

Another feature was a template kind of feature for creating web sites where you get pre-configured pages for login, user registration etc. One gets a full website with some color scheme applied and .mdf file in the “App_data” folder. The .mdf database has all the tables for user management and one can generate schema from this .mdf and recreate the tables in Sql Server 2005/2008. One can use the login, user registration pages without doing any changes or writing any code. Now creating a website is just few clicks away. Microsoft is making the life of a developer easy. Is it? I would say nah, with all these automatic features the developer will forget coding and he will become a lazy bum. Nowadays, when I do interviews many a developers don’t know many of the basics, with all these new changes the next generation developers job will have less of coding and more of configuration.

Next feature was the business layer code generation feature from the Entity framework. You need to follow some of the steps in a wizard and select the needed tables from the database and voila you have your Business Access Layer (BAL) auto generated code. If you tie this auto generated BAL layer to a grid and set some properties you have a grid which is capable of adding, deleting, updating, sorting records without writing a single line of code. One also gets search integration using new search extender control where you need set some properties and you can filter your records based on the search criteria.

IntelliTrace

The IntelliTrace feature like Intellisense is going to become a huge hit with developers. With intellitrace you can exactly pinpoint which line of the code threw the exception with values which were passed to the function. Intellitrace feature in combination with Test and Lab management features of VS 2010 is going to rock.

For Architects

For the architects visual studio supports UML diagram drawing capabilities. You can draw class diagrams, dependency diagrams, sequence diagrams etc which were earlier done in Visio or some other tool. The architects can have validation checks on dependency during compile time or whatever policies they have set. For e.g. take a simple e.g. where we have a Presentation layer, Business Access Layer and Data Access Layer. The architect doesn’t want the presentation layer to interact with DAL. He can set a constraint like this and during compile time the system will throw an error if the constraints is broken. Also you can restrict classes in a dll from interacting with other dlls. One can generate sequence diagram from methods by right clicking on the method and selecting some option from the context menu.

Visual Studio Test and Lab management

This feature of VS 2010 just blew my head away. This feature is aimed at the testers but I feel this feature will be a boon to the developers. In this feature the testers will have provision to add their manual test steps and record them and then replay them. The feature works like this. The testers will first enter all the manual test steps like the following in an UI.

1. “Open IE and type the following url: http://someone.com”.

2. Click register link from the UI.

3. Fill first name with “Sandeep”

4. Fill last name with “P.R”

5. Fill email field with “sndppr@gmail.com”

6. Fill the password field with “123456”

7. Fill the confirm password field with “123456”

8. Click the “Register” button.

Once the steps are done the tester can now start recording the steps. The advantage of this feature is that if there is an error in step 8 the tester need not repeat all the steps manually. Once the recording is over he can replay the steps upto step 8 and he need not manually do all the above steps. Think of a situation where there are 50 steps and the error happens in the 45th step then once the bug is fixed the tester has to repeat all the 44 steps manually to reach the 45th step which threw error. Just by recording the steps he can play them back up to the 44th step and then carry on the recording from the 45th step. Can you imagine how much time will be saved on this? It will be huge. Hats off to Microsoft for this.

That’ not all. What happens when a tester posts a bug? Bang comes the reply from the developer, “it works on my system, so sorry boss its not a bug”. Some developer even go to the extend where they ask to reproduce the bug. Poor tester, he has to repeat the whole 44 steps to show the bug. Not any more. Once the tester finds a bug he can use the new features to post the bug while he is recording and can assign the bug to a developer. The developer when he gets the bug has got links to view the video of the recording where he can exactly see what the tester has done to reproduce the error. Now there will be no more tester developer acrimony. Also to top it all he will get the IntelliTrace link along with the link to view the video. When the developer clicks the IntelliTrace link, it goes to repository (Team Foundation Server [TFS]) and opens your code and shows you the exact place where the error occurred. Not only this, it gives you the exact values which were used by the tester and which were passed to the function. Just by clicking a link you can know the exact line number where the error has happened and the data which caused the problem. Isn’t it so cool. IntelliTrace is gonna ROCK. Developers, our life is going to be simple. :) With IntelliTrace, I think, the bug fixing time taken by the developers will be reduced to 1/4th of what a normal developer takes. Wow that’ really superb. After all time is money.

With the above features and many more, Visual Studio 2010 is going to ROCK. Waiting to get my hands dirty with VS 2010.

Try to know more….

Sandeep

Extending the membership provider.

2010-02-07T22:52:00.001+05:30

Lots of people ask this question on how to extend the “MembershipProvider” to make use of custom authentication like using existing database or make use of some other way of authentication. Many blogs show you how to extend the membership provider class but don’t give you what other class they have used in the backend. With this blog I would not only show how to extend MembershipProvider class but will give you the full source code of the web service which is used instead of a database as a backend.

I have made use of the MembershipProvider many a times but I would like to share my experience in one of my project where I had to extend the MembershipProvider class to make use of an already existing web service of the client to validate user, create user, change password etc. In this blog I will show how to extend MembershipProvider class and write your custom MembershipProvider class.

Since I cannot reveal what webserivce was used in the website developed for the client I will create my own webservice to mimic the exact behavior as in the website. So lets start by creating a webservice which will have methods to create a user, validate user credentials and finally change the user’ password. Once the webservice is done we will extend the membership class. Below is the code for the webservice.

[WebService(Namespace = "http://tempuri.org/")]
[WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
public class WebServiceAuthentication : System.Web.Services.WebService
{
    string xmlFilePath = string.Empty;
    public WebServiceAuthentication()
    {
        xmlFilePath = Server.MapPath("data/users.xml");
    }

    [WebMethod]
    public bool ChangePassword(string username, string newpassword)
    {
        XDocument users = XDocument.Load(xmlFilePath);
        var user = from u in users.Elements("user")
                   where u.Element("username").Value.ToLower() == username.ToLower()
                   select u;
        if (user != null && user.Count() > 0)
        {
            user.First().Element("password").Value = newpassword;
            return true;
        }

return false;
}

    [WebMethod]
    public bool ValidateUser(string userName, string passWord)
    {
        XDocument users = XDocument.Load(xmlFilePath);
        var user = from u in users.Element("users").Elements("user")
                   where u.Element("username").Value.ToLower() == userName.ToLower() && u.Element("password").Value == passWord
                   select u;
        if (user != null && user.Count() > 0)
            return true;
        return false;
    }

    [WebMethod]
    public Customer CreateUser(string username, string password, string emailID)
    {
        XDocument users = XDocument.Load(xmlFilePath);
        var user = from u in users.Elements("user")
                   where u.Attribute("email").Value.ToLower() == username.ToLower()
                   select u.Attribute("email").Value;
        if (user.Count() <= 0)
            throw new Exception("Email already in user");
        else
        {
            users.Element("users").Add(new XElement("user",
                new XAttribute("email", emailID),
                new XElement("userName", username),
                new XElement("password", password)));
            users.Save(xmlFilePath);
        }

return new Customer { UserName = username };
}

    [WebMethod]
    public string ResetPassword(string username)
    {
        string newPass = string.Empty;
        XDocument users = XDocument.Load(xmlFilePath);
        var user = from u in users.Elements("user")
                   where u.Element("username").Value.ToLower() == username.ToLower()
                   select u;
        if (user != null && user.Count() > 0)
        {
            newPass = Guid.NewGuid().ToString().Substring(0, 10);
            user.First().Element("password").Value = newPass;
        }
        else
            throw new Exception("User not found.");

return newPass;
}

    [WebMethod]
    public bool UpdateCustomer(Customer customerToBeUdpated)
    {
        XDocument users = XDocument.Load(xmlFilePath);
        var userToBeUpdated = (from u in users.Elements("user")
                              where u.Attribute("email").Value.ToLower() == customerToBeUdpated.UserName.ToLower()
                              select u);
        if (userToBeUpdated != null && userToBeUpdated.Count() > 0)
        {
            XElement user = userToBeUpdated.First();
            user.Element("password").Value = customerToBeUdpated.Password;
            if (user.Element("firstname") != null)
                user.Element("firstname").Value = customerToBeUdpated.FirstName;
            else
                user.Add(new XElement("firstname", customerToBeUdpated.FirstName));
            if (user.Element("lastname") != null)
                user.Element("lastname").Value = customerToBeUdpated.LastName;
            else
                user.Add(new XElement("lastname", customerToBeUdpated.LastName));
            if (user.Element("address") != null)
            {
                user.Element("address").Element("street").Value = customerToBeUdpated.Address.Street;
                user.Element("address").Element("city").Value = customerToBeUdpated.Address.City;
                user.Element("address").Element("state").Value = customerToBeUdpated.Address.State;
                user.Element("address").Element("country").Value = customerToBeUdpated.Address.Country;
            }
            else
            {
                user.Add(new XElement("address", new XElement("street", customerToBeUdpated.Address.Street),
                    new XElement("city", customerToBeUdpated.Address.City),
                    new XElement("state", customerToBeUdpated.Address.State),
                    new XElement("country", customerToBeUdpated.Address.Country)));
            }

return true;
}

return false;
}
}

In the above web service we have methods to change the password (ChangePassword), to validate user credential based on user name and password (ValidateUser), method to create a user (CreateUser), method to change the password (ResetPassword) and finally method to update user details (UpdateCustomer). All these methods work on a XML file and make use of LINQ to XML to create user, change password etc. As mentioned before all the data is stored and retrieved from a XML file called Users.xml. If a new user has to be added or user details needs to be updated or password needs to be changed everything is done in the xml. The webservice makes use of a XML as a storage medium.The XML is pasted below.

<?xml version="1.0" encoding="utf-8" ?>
<users>
<user email="a@a.com">
    <username>sandeep</username>
    <password>pass</password>
    <firstname>Sandeep</firstname>
    <lastname>P.R</lastname>
    <address>
      <street>Blah blah</street>
      <city>City</city>
      <state>State</state>
      <country>Country</country>
    </address>
</user>
<user email="sndppr@gmail.com">
    <username>sndppr@gmail.com</username>
    <password>pass</password>
    <firstname>Sandeep</firstname>
    <lastname>P.R</lastname>
    <address>
      <street>Blah blah</street>
      <city>City</city>
      <state>State</state>
      <country>Country</country>
    </address>
</user>
</users>

The xml is pretty much straight forward. The XML stores the user name, password and other user related details like his address and email id. In the XML the password is saved as plain text which is not a good way of storing password. So while storing password in a physical file do use some sort of encryption.

Some of the methods of the web service return “Customer” as an object. The “Customer” class is also very straight forward. It derives from the “System.Web.Security.MembershipUser” class and adds some of its own properties. The “Customer” class code is pasted below.

public class Customer : System.Web.Security.MembershipUser
{
public Customer()
{

}

private string userName = string.Empty;

    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string UserName { get; set; }
    public string EMail { get; set; }
    public string Password { get; set; }
    public Address Address { get; set; }
}

public class Address
{
    public string Street { get; set; }
    public string City { get; set; }
    public string State { get; set; }
    public string Country { get; set; }
}

That’s about web serivce and the XML file which form the backend, now lets try to extend System.Web.Security.MembershipProvider to work in conjunction with the above web service. Before that lets keep some things in mind. If you are not planning to make use of question and answer to reset the password then make sure that you return false from “RequiresQuestionAndAnswer” property. If you leave the default implementation then the system will throw “Sysmtem.NotImplementedException” with the following error message.

The method or operation is not implemented.

Now lets see the code where I have extended the System.Web.Security.MembershipProvider class. Some of the methods which have not been implemented have been removed for brevity.

public class CustomMembershipProvider : System.Web.Security.MembershipProvider
{
    public CustomMembershipProvider() : base()
    {
    }

    public override string ApplicationName
    {
        get
        {
            return "Authentication";
        }
        set
        {
            throw new NotImplementedException();
        }
    }
    //Non implemented methods have been removed for brevity.
    public override bool ChangePassword(string username, string oldPassword, string newPassword)
    {
        WebServiceAuthentication wsa = new WebServiceAuthentication();
        return wsa.ChangePassword(username, newPassword);
    }

    public override MembershipUser CreateUser(string username, string password, string email, string passwordQuestion, string passwordAnswer, bool isApproved, object providerUserKey, out MembershipCreateStatus status)
    {
        MembershipUser cust = this.GetUser(username, false);

        if (cust == null)
        {
            WebServiceAuthentication wsa = new WebServiceAuthentication();
            cust = wsa.CreateUser(username, password, email);
            status = cust != null ? MembershipCreateStatus.Success : MembershipCreateStatus.UserRejected;
        }
        else
            status = MembershipCreateStatus.DuplicateUserName;
        return cust;
    }

    public override MembershipUser GetUser(string username, bool userIsOnline)
    {
        WebServiceAuthentication wsa = new WebServiceAuthentication();
        MembershipUser mu = wsa.GetUser(username);
        return mu;
    }

    public override int MinRequiredNonAlphanumericCharacters
    {
        get { return 0; }
    }

    public override int MinRequiredPasswordLength
    {
        get { return 2; }
    }

    public override bool RequiresQuestionAndAnswer
    {
        get { return false; }
    }

    public override bool RequiresUniqueEmail
    {
        get { return false; }
    }
    //Non implemented methods have been removed for brevity

    public override void UpdateUser(MembershipUser user)
    {
        WebServiceAuthentication wsa = new WebServiceAuthentication();
        wsa.UpdateCustomer(user);
    }

    public override bool ValidateUser(string username, string password)
    {
        WebServiceAuthentication wsa = new WebServiceAuthentication();
        if (wsa.ValidateUser(username, password))
        {
            FormsAuthenticationTicket fat = new FormsAuthenticationTicket(1, username, DateTime.Now, DateTime.Now.AddMinutes(30), true, string.Empty);
            HttpCookie authCookie = new HttpCookie(FormsAuthentication.FormsCookieName, FormsAuthentication.Encrypt(fat));
            HttpContext.Current.Request.Cookies.Add(authCookie);
            return true;
        }
        else
        {
            return false;
        }
    }
}

In above code I have extended the MembershipProvider class and overridden “ChangePassword”, “CreateUser”, “GetUser”, “UpdateUser” and “ValidateUser” methods. All these methods are pretty straight forward, the methods create an instance of our web service class and call the web methods to change password, create user etc. The before mentioned membership methods are called by the various login controls provided in ASP.NET. “ChangePassword” is called by the “ChangePassword” control when you click the “Change Password” button. “CreateUser” method of the MembershipProvider class is executed when you click the “Create User” button of “CreateUserWizard” control. “ValidateUser” method is called whenever the user request needs validation or when you click the “Log in” button of the “Log in” control.

Once you have extended the MembershipProvider class add the following tag in the web.config file of your website.

In the above markup the "defaultProvider" is an optional parameter. If not provided it will default to "AspNetSqlProvider", the default provider provided by Microsoft. The "type" attribute has the name of the extended membership provider class. In our case, since the class is placed in the "App_Code" folder, we have only specified the class name. If your membership provider class lies in some different dll and you have added it as a reference to your website then one has to specify the full name preceded by the namespace as well. Also using the “add” tag in “providers” tag you can set the membership properties like "connectionStringName", "enablePasswordRetrieval", "enablePasswordReset" etc in the. Sample tag is pasted below.

With this done you can drag and drop the various ASP.NET login controls like the CreateUserWizard, ChangePassword, Login etc and you can create users, change password and login into the application without writing any code in the code behind files where these ASP.NET login controls are used. Isn’t it so easy to use the various ASP.NET login controls once you have extended the MembershipProvider class.

Try to know more

Sandeep

Serialization in .NET – 5

2010-01-19T21:44:00.001+05:30

In my previous blogs we have seen Binary serialization, XML serialization, SOAP serialization and Custom serialization using ISerilizable interface. This blog will talk about implementing custom XML serialization using the IXmlSerializable interface. We have seen in my previous blogs on serialization how to control XML and SOAP serialization using attributes. Through attributes we can take control to some extent but not to the fullest. If you want to take full control over the way your class is serialized to XML then you need to use IXmlSerializable interface.

Implementing IXmlSerializable interface is pretty straight forward. The interface has three methods namely “WriteXml (XmlWriter writer)”, “ReadXml (XmlReader reader)” and “GetSchema()”. WriteXml method is called when the object is serialized and ReadXML method is executed when the XmlSerializer deserializes the object. GetSchema method returns a XmlSchema object. As such the GetSchema method is not supposed to do anything other than returning null. The help documentation from MSDN says the following about the method.

“When serializing or deserializing an object, the XmlSerializer class does not perform XML validation. For this reason, it is often safe to omit schema information by providing a trivial implementation of this method, for example by returning nullNothingnullptra null reference (Nothing in Visual Basic) (Nothing in Visual Basic).

If providing schema information is necessary, you should use the XmlSchemaProviderAttribute attribute. The GetSchema method should still return nullNothingnullptra null reference (Nothing in Visual Basic) (or Nothing).

Some .NET Framework types as well as legacy custom types implementing the IXmlSerializable interface may be using GetSchema instead of XmlSchemaProvider. In this case, the method returns an accurate XML schema that describes the XML representation of the object generated by the WriteXml() method.”

Lets dive into the code and implement the interface in our good old “Car” class. One thing to keep in mind before implementing IXmlSerializable interface is that the class which implements the interface should have a parameter less constructor. If the class which is implementing IXmlSerializable interface doesn’t have a parameter less constructor then on serialization the following error will be thrown.

Vehicles.Car cannot be serialized because it does not have a parameterless constructor.

Below is the Car class with IXmlSerializable interface implementation.

[System.Xml.Serialization.XmlRoot(Namespace="http://car/car")]
public class Car : System.Xml.Serialization.IXmlSerializable
{
    #region Properties
    public string Color
    { get; set; }

public string ModelName
{ get; set; }

public int Price
{ get; set; }

    public double CubicCentimeter
    { get; set; }
    #endregion

#region IXmlSerializable Members

    System.Xml.Schema.XmlSchema System.Xml.Serialization.IXmlSerializable.GetSchema()
    {
        throw new NotImplementedException();
    }

    void System.Xml.Serialization.IXmlSerializable.ReadXml (System.Xml.XmlReader reader)
    {
        string ns = "http://car/car";
        if (reader.NodeType == System.Xml.XmlNodeType.Element && reader.Name == "Car")
        {
            reader.MoveToAttribute("Price");
            this.Price = reader.ReadContentAsInt();
            reader.MoveToElement();
        }

reader.Read();

        if (reader.NodeType == System.Xml.XmlNodeType.Element && reader.Name == "ModelName")
        {
            this.ModelName = reader.ReadElementContentAsString();
        }

        if (reader.NodeType == System.Xml.XmlNodeType.Element && reader.Name == "CC")
        {
            this.CubicCentimeter = reader.ReadElementContentAsDouble() ;
        }

        if (reader.NodeType == System.Xml.XmlNodeType.Element && reader.Name == "Color")
        {
            this.Color= reader.ReadElementContentAsString();
        }
    }

    void System.Xml.Serialization.IXmlSerializable.WriteXml (System.Xml.XmlWriter writer)
    {
        string ns = "http://car/car";
        writer.WriteStartAttribute("Price");
        writer.WriteString(this.Price.ToString());
        writer.WriteEndAttribute();
        writer.WriteStartElement("ModelName", ns);
            writer.WriteString(this.ModelName);
        writer.WriteEndElement();
        writer.WriteStartElement("CC", ns);
            writer.WriteString(this.CubicCentimeter.ToString());
        writer.WriteEndElement();
        writer.WriteStartElement("Color", ns);
            writer.WriteString(this.Color);
        writer.WriteEndElement();
    }

#endregion
}

The above code is pretty straight forward, in the WriteXml method we are making use of the XmlWriter class and serializing the Car class in our customized way. We are writing the Price property as an attribute to the root element by making use of the “WriteStartAttribute” method of the XmlWriter class. Similarly we are making use of “WriteStartElement” method of the XmlWriter class to write the other properties as an element node. The XML generated by WriteXml is pasted below.

<?xml version="1.0"?>
<Car Price="23423" xmlns="http://car/car">
<ModelName>Beetle</ModelName>
<CC>0</CC>
<Color>Yellow</Color>
</Car>

Seeing the XML output you will be thinking that in “WriteXml” method we have not written code to write the “Car” root node, then how come there is a root node? The reason is that when the XmlWriter object, which is passed as an argument to the WriteXml method, already has the root node. By default the name of the root node will be the class name itself. If you notice we have placed the “XmlRoot” attribute on the “Car” class. So if you want to control the root name then you have to make use of the “XmlRoot” attribute.

In the ReadXml method we are making use of XmlReader class to read the Xml serialized using the WriteXml method and reconstructing our Car class. When the Car class is deserialized the XML serializer executes the ReadXml method by passing the XmlReader class as an argument. When ReadXml is called the reader is positioned at the start of the document. The ReadXml function is making use of various methods of the XmlReader class to read the content of the XML and reconstructing our serialized Car class. We are checking whether the reader is currently pointing to a attribute or element and then making use of appropriate methods to read the content.

Since there is no validation happening during serializing and deserializing we have left the “GetSchema” method empty. If you really want to return a schema then what should you do?

Returning a schema from IXmlSerializable implemented class.

In scenarios where you want to return a schema file one should apply “XmlSchemaProvider” attribute to the IXmlSerializable implemented class. “XmlSchemaProvider” contains the name of the method which returns the schema for the class. The method which is specified in the “XmlSchemaProvider” should be static. Also the method should return an object of type “XmlQualifiedName” and should take “XmlSchemaSet” object as an argument. The method should take the responsibility of filling the “XmlSchemaSet” object passed as an argument. If you are applying “XmlSchemaProvider” to a class then make sure the schema files don’t have any schema errors else error will thrown during the serialization process.

Everything apart lets see how to implement “XmlSchemaProvider” attribute on a IXmlSerialization implemented class. Below is the Car class with the “XmlSchemaProvider” attribute applied. I have pasted only the relevant code.

[System.Xml.Serialization.XmlSchemaProvider("ReturnSchema")]
public class Car : System.Xml.Serialization.IXmlSerializable
{
/*Code has been trimmed for brevity*/

    public static System.Xml.XmlQualifiedName ReturnSchema (System.Xml.Schema.XmlSchemaSet xs)
    {
        System.Xml.Serialization.XmlSerializer xmlSer = new System.Xml.Serialization.XmlSerializer(typeof (System.Xml.Schema.XmlSchema));
        System.Xml.Schema.XmlSchema xmlSchema = (System.Xml.Schema.XmlSchema) xmlSer.Deserialize (new System.Xml.XmlTextReader("CustomSerilize_app1.xsd"));
        xs.XmlResolver = new System.Xml.XmlUrlResolver();
        xs.Add(xmlSchema);
        return new System.Xml.XmlQualifiedName ("Car", “http://car/car”);
     }
}

I don’t think the above code needs much of an explanation. In the first few lines of code we are pumping the XmlSchema object with the schema information by reading the schema file from disk. Once that is done we are returning a XmlQualifiedName object.

That’ about customizing XML serialization. Isn’t it so easy to write custom XML serialization. Whenever you find a situation where you want to serialize your class into XML and you don’t want to leave it to the system and want to take full control of the serialization, you can implement IXmlSerializable interface to your class.

Try to know more

Sandeep

Displaying trademark, copyright etc in HTML

2010-01-02T17:56:00.000+05:30

This blog talks about a simple trick on how to show the trademark, copyright and registered symbols in HTML. To display trademark, copyright and registered symbols one needs to use “™”, “©” and “®” respectively with any of the html tags. Below are some html and ASP.NET code samples.

//Trademark symbol displayed in the title window.
<title>My Company ™</title>
//Copyright symbol in a table header
<table width="100px">
<tr><th> Heading ©</th></tr>
</table>
//Registered symbol in a ASP.NET textbox
<asp:TextBox ID="TextBox1" runat="server" Text="®"></asp:TextBox>
//Trademark, copyright and registered symbol in a ASP.NET label control
<asp:Label ID="Label2" runat="server" Text="™ © ®"></asp:Label>

Try to know more.

Sandeep

Data type validation using validation control

2009-12-23T19:23:00.000+05:30

While developing ASP.NET application you would have come across scenarios where you would like to validate whether the value entered is of a particular data type. The options available with an ASP.NET developer is to write javascript functions to check whether the entered value complies with a data type or make the page postback and check the data type in server side. These two options are time consuming. Is there any simple way of doing this? The answer is to the question is “YES”. One can make use of compare validator to accomplish the task very easily. Lets see how.

To compare whether the entered value is of a particular data type one should make sure that the “Operator” property of compare validator should be “DataTypeCheck” and the “Type” property should be the data type you want to check. These two things are the only requirement to validate the data type. Compare validator supports validation for Currency, Date, Double, Integer and String data type. Below is a sample code which tries to check all these data types.

Enter string: <asp:TextBox ID="txtString" runat="server"></asp:TextBox>
<asp:CompareValidator ID="cmpVldString" runat="server" ErrorMessage="Not a valid string." ControlToValidate="txtString"
Type="String" Operator="DataTypeCheck"> </asp:CompareValidator><br />
Enter integer: <asp:TextBox ID="txtInt" runat="server"> </asp:TextBox>
<asp:CompareValidator ID="CompareValidator1" runat="server" ErrorMessage="Not a valid Integer." ControlToValidate="txtInt"
Type="Integer" Operator="DataTypeCheck"> </asp:CompareValidator><br />
Enter double: <asp:TextBox ID="txtDouble" runat="server"> </asp:TextBox>
<asp:CompareValidator ID="CompareValidator2" runat="server" ErrorMessage="Not a valid double." ControlToValidate="txtDouble"
Type="Double" Operator="DataTypeCheck"> </asp:CompareValidator><br />
Enter date: <asp:TextBox ID="txtDate" runat="server"> </asp:TextBox>
<asp:CompareValidator ID="cmpVldDate" runat="server" ErrorMessage="Not a valid date." ControlToValidate="txtDate"
Type="Date" Operator="DataTypeCheck" > </asp:CompareValidator><br />
Enter currency: <asp:TextBox ID="txtCurrency" runat="server"> </asp:TextBox>
<asp:CompareValidator ID="cmpVldCurrency" runat="server" ErrorMessage="Not a valid currencys." ControlToValidate="txtCurrency" Type="Currency" Operator="DataTypeCheck" > </asp:CompareValidator><br />
<asp:Button ID="Button1" runat="server" Text="Button" />

In the above code sample you can see that I am checking the datatype for string, Integer, date, double and finally currency. Isn’t it so easy to check the data type?

Now since we are validating date you would like to check against a particular format say “DD/MM/YYYY”. The default date format against which the compare validator checks the date is “YYYY/MM/DD”. One way specify the date format is to assign the page’ culture to the required culture which supports your date format. Say we want to check “DD/MM/YYYY” then we can set the following in the code behind.

protected void Page_Load(object sender, EventArgs e)
{
Page.Culture = "hi-IN";

In the above code we are setting the culture for the page as Hindi-India which will accept the date in “DD/MM'/YYYY” format. Another way specifying the format in compare validator is to assign culture to the control which is specified in “ControlToValidate” property of the compare validator. For e.g. you have date picker assigned to a compare validator then assigning the culture or date format to the date picker will do the trick. As such there is no way to specify date format or culture to a compare validator.

Note: When you use compare validator to check currency data type keep in mind it doesn’t check for currency symbol compliance.

Try to know more…..

Sandeep

Retrieving controls from an ASP.NET GridView control using javascript.

2009-12-21T17:29:00.000+05:30

In our day to day ASP.NET programming we would have used GridView for one or the other purpose. There would have been requirement to access the controls inside a GridView from javascript. Whenever I had to use the ASP.NET GridView control, nearly 95% of the time I had to access the controls inside the GridView using javascript for one or the other purpose. With this blog I wanted to show how easily you can retrieve controls rendered inside a GridView from javascript. I would like to highlight this by taking an age old design where you will have a checkbox in the header and another set of checkboxes in the column below. Checking the checkbox in the header would select all the checkboxes in the column and un-checking a single checkbox in the column would un-check the header checkbox. This strategy can be used to access any type of controls not only inside the GridView but other data rendering controls as well. Now lets see the code for the same.

<asp:GridView ID="gvChk" runat="server" AutoGenerateColumns="False"
            BackColor="White" BorderColor="#DEDFDE" BorderStyle="None" BorderWidth="1px"
            CellPadding="4" ForeColor="Black" GridLines="Vertical"
            onrowdatabound="gvChk_RowDataBound">
            <RowStyle BackColor="#F7F7DE" />
            <Columns>
                <asp:TemplateField HeaderText="Sl. No">
                    <EditItemTemplate>
                        <asp:TextBox ID="TextBox1" Text='<%#Eval("No") %>' runat="server"></asp:TextBox>
                    </EditItemTemplate>
                    <ItemTemplate>
                        <asp:Label ID="Label1" runat="server" Text='<%#Eval("No") %>'></asp:Label>
                    </ItemTemplate>
                </asp:TemplateField>
                <asp:TemplateField>
                    <EditItemTemplate>
                        <asp:CheckBox ID="CheckBox1" runat="server" />
                    </EditItemTemplate>
                    <ItemTemplate>
                        <asp:CheckBox ID="CheckBox1" runat="server" />
                    </ItemTemplate>
                    <HeaderTemplate>
                        <asp:CheckBox ID="chkHeader" onclick="javascript:selectAllCheckboxInGrid(<% gvChk.ClientID; %>, this);"
                            runat="server" />
                    </HeaderTemplate>
                </asp:TemplateField>
            </Columns>
            <FooterStyle BackColor="#CCCC99" />
            <PagerStyle BackColor="#F7F7DE" ForeColor="Black" HorizontalAlign="Right" />
            <SelectedRowStyle BackColor="#CE5D5A" Font-Bold="True" ForeColor="White" />
            <HeaderStyle BackColor="#6B696B" Font-Bold="True" ForeColor="White" />
            <AlternatingRowStyle BackColor="White" />
</asp:GridView>

The code is very simple with a GridView control having two columns. First column has a label control and second one has a checkbox control. The second column has a checkbox in the header as well. When checkbox in the header is clicked all the checkboxes in the column are selected using javascript. The javascript code to select all the checkboxes in the column are pasted below.

The above pasted javascript is straight forward. The javascript function takes two arguments, one is the GridView’ client id and the second is the checkbox in the GridView control’ header. The function starts by getting the grid control using the “getElementById” javascript method of the document object. After getting the GridView control, which is converted to a HTML table once rendered to the browser, we are looping through the rows collection starting from the first row. The zeroth row is the header so we don’t want the loop to start from the header. Starting from the 1st row we loop through the whole rows and get the controls in the second cell of the GridView using the “getElementsByTagName” method of the document object. Then we loop through the control array and check the type of the control and if it is a checkbox we set the checked property based on the checkbox control of the header cell passed as an argument to the javascript function. If you have only one control in the cell then you can directly use “cells[1].children[0].checked = chk.checked” so that you can avoid the loop. The above modified code is pasted below.

Next we have to have a function which will check the header checkbox if all the checkbox in the column are checked and if out of all the checked checkboxes anyone is unchecked then we need to uncheck the header checkbox. The simple function is fired when any of the checkboxes in the column are clicked. The javascript function is pasted below.

The above function is pretty straight forward. The “GridView” control id is passed as argument. The function gets the “GridView” control using the “getElementById” function of the document object and loops through the rows starting from the first row leaving the zeroth row. Inside the loop the function retrieves the controls inside the second cell of each row and checks whether any one of the checkbox is unchecked. If so it assigns the “checked” variable as false and breaks the loop. Finally it sets the checked property of the checkbox in the header (zeroth row) to the value of “checked” variable. This function will take care of checking or unchecking the checkbox if all the checkbox in the column are checked or if any one checkbox in the checkbox column is unchecked respectively.

To fire the javascript function on the click of the checkboxes we need to add the javascript function to the “onclick” javascript event. To do this add the following in the “RowDataBound” event of the GridView control.

protected void gvChk_RowDataBound(object sender, GridViewRowEventArgs e)
{
    //Check if the row is of header type.
    if (e.Row.RowType == DataControlRowType.Header)
    {
        //Add the javascript function which gets called
        //when the checkbox in the header is clicked.
        (e.Row.FindControl("chkHeader") as CheckBox).Attributes.Add("onclick", "javascript:selectAllCheckboxInGrid('" + gvChk.ClientID + "', this);");
    }
    else if (e.Row.RowType != DataControlRowType.Footer)
    {
        //Add the javascript function call which gets called
        //when the checkboxes in the column are clicked.
        (e.Row.FindControl("CheckBox1") as CheckBox).Attributes.Add("onclick", "javascript:checkUncheckHeaderCheckBox('" + gvChk.ClientID + "');");
    }
}

With the above code we are ready to go.

The above technique using javascript can be used to retrieve any type of controls (textbox, dropdown, radio button, button, links, images, labels etc) from within the GridView control or any other ASP.NET data rendering controls. You need to make some small javascript changes according to your data bound controls layout. So tweak the code wherever necessary and start retrieving controls.

Try to know more…

Sandeep

Serialization in .NET - 4

2009-12-15T19:38:00.000+05:30

In my previous blogs on serialization we had looked at the different ways of serializing an objects in .NET. The links to my previous blogs are

Soap Serialization

XML serialization

Binary serialization

In this blog we will have a look at how to implement custom serialization using ISerializable interface. In my previous blogs on serialization we looked at ways of controlling serialization by way of applying various attributes to the class and its member variables. Applying attributes gives us some control over serialization but doesn’t provide full fledge control. Most of your day to day serialization requirement can be met with the attributes discussed in my previous articles. But if you are the one who wants to take full control over serialization, then ISerializable interface is there for you. Lets first see what is needed to implement ISerializable interface.

The ISerializable interface has got only one method, GetObjectData. In addition to implementing the GetObjectData the implementer should also take care to implement a special constructor to classes implementing ISerializable interface. The constructor is called by the system during the de-serialization process to reconstruct the serialized object. If by chance you forgot to implement the constructor, runtime error will be thrown when one tries to deserialize a class implementing ISerializable interface without the special constructor. The “System.Runtime.Serialization.SerializationException” exception message which is thrown at runtime is pasted below.

The constructor to deserialize an object of type 'ISerializableImplementation.[CLASSNAME]' was not found.

Note: “GetObjectData” will be executed only in the case of binary serialization. For custom serialization in XML and SOAP serialization you need to implement IXmlSerializable interface.

Now lets see and try to understand the GetObjectData and the special constructor.

GetObjectData: The ISerializable method has only one method to be implemented and the signature looks like this “GetObjectData((SerializationInfo info, StreamingContext context)”. The method takes SerializationInfo object as the first argument. SerializationInfo class can be used to store the required data to serialize and deserialize an object. Its the responsibility of the implementer to fill the SerializationInfo class with the necessary data. The implementer can decide on which member variables to store and which ones he doesn’t want to save. While doing this care should be taken to see that sufficient information is serialized for the objects to be deserialized. You can use the “AddValue” overloaded methods to add values to the SerializationInfo class. StreamingContext, the second argument in the method can be used to check the source from which the serialization request has come. Use the StreamingContext.State to check the source. Usage of StreamingContext is given at the end of the blog.

Special constructor: The signature of the special constructor is as follows “(SerializationInfo info, StreamingContext context)”. The paremeters for the constructor are also the same. So I will not spend time explaining these. The special constructor is executed when an object (whose class has implemented ISerializable interface) is deserialized. If the special constructor is not implemented the system will not throw any compile time error but it will throw a runtime exception. So make sure a class which implements ISerializable interface has an explicit implementation of the special constructor which takes SerializationInfo and StreaminContext as its constructor argument. The special constructor should be private or protected if you intent to inherit the class.

Things to note before you implement ISerializable interface

Keep the following things in mind before you implement the ISerializable Interface.

The class should have the Serializable attribute applied to it. If the class is not marked with the Serializable attribute an exception of type “System.Runtime.Serialization.SerializationException” will be thrown with the following error message.

Type 'ISerializableImplementation.[CLASSNAME]' in Assembly 'ISerializableImplementation, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null' is not marked as serializable.

NonSerializable attribute should not be used as it will not have any effect.
Special constructor with the same argument as that of GetObjectData method must be implemented and should be private or protected.
If the ISerializable implemented class is derived from a base class which also implements ISerializable interface then the parent class’ GetObjectData and special constructor should be called before the child class’ function and special constructor.

That’ enough about the ISerializable interface implementation, now you will be eager to see the real implementation. The implementation is also pretty easy and straight forward. As usual lets take the Car class and implement ISerializable interface to it. The code sample is pasted below.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.Serialization;

namespace ISerializableImplementation
{
    [Serializable]
    public class Car : ISerializable
    {
        public Car()
        {}

        public string Color
        { get; set; }
        public string ModelName
        { get; set; }
        public int Price
        { get; set; }
        public double CubicCentimeter
        { get; set; }

#region ISerializable Members

#endregion
}
}

In the above code we have a special constructor and the GetObjectData method needed to implement custom serialization. GetObjectData method is called when a Car object is serialized and the special constructor is executed when the de-serialization of the Car object happens. Also if you notice, inside, GetObjectData method we are changing the property names, “Color” is changed to “CarColor”, “ModelName” is changed to “Model” and “CubicCentimeter” to CC. These are simple e.g. where we are taking control of serialization. Similar to this you can take control based on different scenarios. If you notice we have not included the “Price” in the serialization and deserialization process i.e. in GetObjectData and special constructor respectively.

Isn’t it so simple to implement custom serialization. Now lets see how to use the StreamingContext object in serialization and deserialization. “StreamingContext” has only two properties which can be of interest, they are “Context” and “State”. Context property can hold any type of object as the underlining type is an “System.Object” class. Context property can be used when you expect some sort of object to come from the caller when serialization is happening. State property tells us from which source the serialization request has been raised. Lets understand with an e.g.

void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
{
      info.AddValue("CarColor", this.Color);
      info.AddValue("Model", this.ModelName);
      info.AddValue("CC", this.CubicCentimeter);
      //If the request comes from other sources then retrieve the price from the HashTable in the "Context"
      // property of StreamingContext class.
      if (context.State == StreamingContextStates.Other)
      {
          info.AddValue("Price", ((System.Collections.Hashtable)context.Context)["Ferari Mondeno"].ToString());
      }
}

In the above code I have pasted the modified “GetObjectData” method as the other structure of the Car class is same. What we have done in the method is we have added a checking to check whether the serialization request is coming from other sources, if it is then get the price value from the “Context” property of the StreamingContext object. If you see the code I am casting the object to Hashtable and retrieving the price by passing “Ferari Mondeno” string as key. Lets see how the serialization code for the above implementation should be called.

//Create a Hashtable object and add the necessary data.
System.Collections.Hashtable ht = new System.Collections.Hashtable();
ht.Add("Ferari Mondeno", 324324);
ht.Add("Lamborgini", 56677);
//Create StreamingContext instance by passing the Hashtable
//as one of the arguments. Also we are setting the
//StreaminContextStates as Other.
StreamingContext sc = new StreamingContext(StreamingContextStates.Other, ht);
//Pass the StreamingContext instance as one of the parameters
//of the binary formatter class.
BinaryFormatter bf = new BinaryFormatter(null, sc);
using (System.IO.FileStream fs = new System.IO.FileStream("Serialized.txt", System.IO.FileMode.Create))
{
    Car car = new Car { ModelName = "Ferari Mondeno", Color = "Ferari Red", CubicCentimeter = 23584.33, Price = 234656 };
    //bf.Serialize(Console.OpenStandardOutput(), car);
    bf.Serialize(fs, car);
}

In the above code you can see that we are first creating a Hashtable with the necessary data. Once that is done we are creating a StreamingContext instance by passing the Hashtable instance and setting the “StreamingConstextstate as “Other”. After this we are passing the StreamingContext instance as one of the arguments to the “BinaryFormatter” class’ constructor. As you would have noticed we are passing Hashtable instance into the “Context” property of the StreamingContext object. Using the Hashtable we are retrieving the price in “GetObjectData” method.

Now lets see how to deserialize object by making use of the StreamingContext instance. Based on the above changes we need to first change the constructor. Below is the constructor code.

public Car(SerializationInfo info, StreamingContext context)
{
    this.Color = info.GetString("CarColor");
    this.CubicCentimeter = info.GetDouble("CC");
    this.ModelName = info.GetValue("Model", typeof(string)).ToString();
    //Checking whether the serialization request is
    //coming from file or from other sources.
    if (context.State == StreamingContextStates.File || context.State == StreamingContextStates.Other)
    {
        this.Price = int.Parse(((System.Collections.Hashtable)context.Context)["Ferari Mondeno"].ToString());
    }
}

In the above code we have just added a if checking to check whether the request is coming from a file or from other sources, If so read the price value from the StreamingContext instance’ Context property. The “Context” property has a Hashatable having prices.

Now lets see the deserialization code for the above.

using (System.IO.FileStream fs = new System.IO.FileStream("Serialized.txt", System.IO.FileMode.Open))
{
    //Create a Hashtable object and add the necessary data.
    System.Collections.Hashtable ht = new System.Collections.Hashtable();
    ht.Add("Ferari Mondeno", 324324);
    ht.Add("Lamborgini", 56677);
    //Create StreamingContext instance by passing the Hashtable
    //as one of the arguments. Also we are setting the
    //StreaminContextStates as Other.
    StreamingContext sc = new StreamingContext(StreamingContextStates.File, ht);
    //Pass the StreamingContext instance as one of the parameters
    //of the binary formatter class.
    BinaryFormatter bf = new BinaryFormatter(null, sc);
    Car deserializedCar = (Car)bf.Deserialize(fs);
    string nl = Environment.NewLine;
    Console.WriteLine(nl + "Model name: {0}, " + nl + "envi Color: {1}, " + nl + "Cubic centimeter: {2}, " + nl + "Price: {3}",
                        deserializedCar.ModelName, deserializedCar.Color, deserializedCar.CubicCentimeter, deserializedCar.Price);
}

There is nothing much to explain about the above code. Its pretty much straight forward and is similar to the code where we have serialized the Car class. That’ it about custom serialization using ISerializable interface. One very important point which I would like to reiterate again is that the “GetObjectData” and the special constructor will be executed only for binary serialization. For XML and SOAP serialization “GetObjectData” and the special constructor will not be executed. To implement custom serialization in XML and SOAP serialization you have to implement IXmlSerializable interface. We will have a look at IXmlSerializable interface implementation in my next blog. Till then try to know more.

Sandeep

Showing image when validation fails using validation control

2009-12-11T22:18:00.003+05:30

As they say .NET is a big ocean and each day you come across something new. Even after working for six years on .NET every other day I learn something new. One such experience I would like to share with this blog. In this blog we will see how to show an image when there is a validation error.

Anyone who is a ASP.NET developer would have used validation control at some point or the other. So with this blog I would like to show a small technique whereby you can show an image next to a control whenever a validation fails using a validation control. The great thing about this approach is that, it is in-built into all the validation controls and to do this one need not write any server side code or client side code. Just placing an image tag in the “ErrorMessage” property of the validation control will do. Lets see the code.

Required Numeric:
<asp:TextBox ID="TextBox1" runat="server"></asp:TextBox>
<asp:RequiredFieldValidator ID="RequiredFieldValidator1" runat="server" ControlToValidate="TextBox1" ErrorMessage='<img src=images/error.gif />' Display="Dynamic"></asp:RequiredFieldValidator>
<asp:Button ID="btnSubmit" runat="server" Text="Submit" CausesValidation="true" CommandName="Edit" />
<asp:Button ID="btnCancel" runat="server" Text="Cancel" CommandName="" CausesValidation="False"
OnClick="btnCancel_Click" />

If you see the above code I have placed a html image tag in the “ErrorMessage” property of the required field validator control. So when you click the submit button without entering any value in “TextBox1” an error image will pop next to the textbox. The screenshot is shown below.

In the above image you can see an image, adjacent to the textbox, which was assigned to the “ErrorMessage” property of the validation control. In the above screenshot one thing which is missing is the description about the error. Wouldn’t it be nice to have a description about the error alongside the image? To achieve just that just place the error message before the html image tag as shown below.

<asp:RequiredFieldValidator ID="RequiredFieldValidator1" runat="server" ControlToValidate="TextBox1" ErrorMessage="Required.<img src=images/imagesCAJD7BX6.jpg />" Display="Dynamic"></asp:RequiredFieldValidator>

From the above you can notice that we have inserted “Required.” text before the image tag. The output of this is pasted below.

Now we have a message alongside the image which gives as the detail of what went wrong. Now all this is fine, but some others would like to make use of the validation summary and show the error messages in the validation summary and error images along side the controls. Hmm, is that tricky? Not at all, its very easy. Lets see how?

Error image along with validation summary control

To show error image alongside the control and validation message in validation summary you have to make some small adjustments in the above code. First thing, obviously, is to insert a validation summary control. Next, Place the image tag in between the starting and ending tags of the validation control. I know you will be little confused, lets clear your confusion with some code. Here is what you need to do.

<asp:RequiredFieldValidator ID="RequiredFieldValidator1" runat="server" ControlToValidate="TextBox1" ErrorMessage="Required." Display="Dynamic"><img src=images/imagesCAJD7BX6.jpg /></asp:RequiredFieldValidator>

In the above code I have purposefully not included the validation summary control. You can find the whole code at the end of the blog. If you notice, we have placed the image tag in between the starting and ending tag of the required field validator. Also we have the error message in the “ErrorMessage” property. The output of the above code is pasted below.

One thing to note here is that you have to set the “Display” property of the validation control to “Dynamic”. If you set the “Display” property to “None”, which we usually use with validation summary control, then the image will not be displayed. So its very important to set the “Display” property to “Dynamic'” for this to work. The whole code along with the validation summary is pasted below.

<asp:ValidationSummary ID="ValidationSummary1" runat="server" />
Required Numeric:
<asp:TextBox ID="TextBox1" runat="server"></asp:TextBox>
<asp:RequiredFieldValidator ID="RequiredFieldValidator1" runat="server" ControlToValidate="TextBox1" ErrorMessage="Required." Display="Dynamic"><img src=images/imagesCAJD7BX6.jpg /></asp:RequiredFieldValidator>
<asp:Button ID="btnSubmit" runat="server" Text="Submit" CausesValidation="true" CommandName="Edit" />
<asp:Button ID="btnCancel" runat="server" Text="Cancel" CommandName="" CausesValidation="False" OnClick="btnCancel_Click" />

Try to learn more

Sandeep

Weird, CausesValidation not working.

2009-12-11T22:18:00.001+05:30

Recently I faced a weird situation where I had some validation controls, a cancel and submit buttons in a page . Submit button would validate the page controls for errors and cancel button would just postback and execute some code on the server without validating the page. The weird thing was once submit button is clicked and if there are any validation errors in the page and then one clicks the cancel button it won’t clear postback. If the user clicks the cancel button for the second time it would trigger postback. This happened even after setting the “CausesValidation” property of the cancel button to “false'”. The cancel button code is pasted below.

<asp:Button ID="btnRemove" CssClass="buttonEnabled" CommandName="Delete" runat="server" meta:resourcekey="btnRemove" CausesValidation="false" />

One thing to note here is that the cancel button was inside a ListView control’ ItemTemplate section. So on click of the button postback should happen and in the server some logic would be carried. The cancel would not work only when the user clicks the submit button and if there are any error and the user wishes to cancel the action then the cancel button would not post back. Only when the user clicks the cancel button for the second time, it would post back. If the user clicks the cancel button immediately after clicking the submit button and there are any validation errors displayed through the validation controls then the cancel button would not postback. This was weird. The solution was also simple. I need to set “Page_ValidationActive” javascript variable to false on the “OnClientClick” property of the cancel button. The modified cancel button HTML is pasted below.

<asp:Button ID="btnRemove" CssClass="buttonEnabled" CommandName="Delete" runat="server" meta:resourcekey="btnRemove" CausesValidation="false" OnClientClick="javascript:Page_ValidationActive = false;" />

Setting the “Page_ValidationActive” to false disables all the validations in the page. So please do keep this in mind. Anyway this is what I wanted and my problem was solved.

Try to know more.

Sandeep

Updating a resource file.

2009-11-30T21:12:00.001+05:30

Recently one of our client had this requirement where they wanted to customize the texts appearing in the website as and when needed i.e. suppose they have a heading text in the login page which says “Login” and at some point they would like to change the text to something like “Login using email and password” without tinkering with the code. This is just an e.g., the client wanted each and every text appearing in the UI to be customizable.

The above requirement can be easily achieved using resource files. The text which are displayed can be placed in the resource files and whenever there is a change in the text just editing the resource file will take care of displaying the new text. Now you might be thinking what is the big deal in this, yes there is no rocket science involved in editing a resource file, just open any text editor and make the necessary modification. Asking the client to do that will be too much in the asking. As resource files are stored as XML, any syntax problem can bring down the whole application. So the next obvious solution is to provide a web page to edit the existing resource files.

By itself .NET doesn’t provide any class to edit and update resource files. There are classes to read and create resource files but nothing as such to update a resource files. If you want to simply read the content of a resource file you can make use of “System.Resources.ResourceReader” class and if you want to dynamically create a resource file then make use of “System.Resource.Resources.ResourceWriter” class. One of the disadvantages of using these classes is that they don’t have facility to fetch the comment part of a resource item.

My problem was not reading or creation of resource file but updating the content. Also I had to update the comments as well. So some googling helped me and gave me hints. People suggested that, treat a resource file as an XML and use the XML classes to read/update the resource file. With this hint and little bit of LINQ to XML I found the solution. Lets dive into the solution.

Reading resource file using LINQ

Following is the HTML content for displaying the resource file content.

<asp:GridView ID="gvResourceEditor" runat="server" AutoGenerateColumns="False" OnRowCancelingEdit="gvResourceEditor_RowCancelingEdit"
            OnRowEditing="gvResourceEditor_RowEditing" OnRowUpdating="gvResourceEditor_RowUpdating"            CellPadding="0" BorderWidth="0px" Width="100%" meta:resourcekey="gvResourceEditorResource1">
            <Columns>
                <asp:TemplateField HeaderText="Key" meta:resourcekey="TemplateFieldResource1">
                    <EditItemTemplate>
                        <asp:Label ID="lblKey" runat="server" Text='<%# Eval("Key") %>' meta:resourcekey="lblKeyResource1"></asp:Label>
                    </EditItemTemplate>
                    <ItemTemplate>
                        <asp:Label ID="lblKey" runat="server" Text='<%# Eval("Key") %>' meta:resourcekey="lblKeyResource2"></asp:Label>
                    </ItemTemplate>
                    <ItemStyle CssClass="gridText tenXPadding bottomBorder rightBorder" Wrap="True" VerticalAlign="Top"
                        Width="10%" />
                </asp:TemplateField>
                <asp:TemplateField HeaderText="TEXT" meta:resourcekey="TemplateFieldResource2">
                    <HeaderStyle BorderWidth="0" BorderColor="White" BorderStyle="None" />
                    <EditItemTemplate>
                        <asp:TextBox ID="txtValue" TextMode="MultiLine" CssClass="textBoxEnabled" runat="server"
                            Text='<%# Bind("Value") %>' Width="100%" Height="150px" meta:resourcekey="txtValueResource1"></asp:TextBox>
                    </EditItemTemplate>
                    <ItemTemplate>
                        <asp:Label ID="lblValue" runat="server" Text='<%# Bind("Value") %>' meta:resourcekey="lblValueResource1"></asp:Label>
                    </ItemTemplate>
                    <ItemStyle CssClass="gridText tenXPadding rightBorder bottomBorder" Wrap="True" Width="35%"
                        VerticalAlign="Top" />
                </asp:TemplateField>
                <asp:TemplateField HeaderText="COMMENTS" meta:resourcekey="TemplateFieldResource3">
                    <HeaderStyle BorderWidth="0" BorderColor="White" BorderStyle="None" />
                    <EditItemTemplate>
                        <asp:TextBox ID="txtComment" TextMode="MultiLine" CssClass="textBoxEnabled" runat="server"
                            Text='<%# Bind("Comment") %>' Width="100%" Height="150px" meta:resourcekey="txtDescriptionResource1"></asp:TextBox>
                    </EditItemTemplate>
                    <ItemTemplate>
                        <asp:Label ID="lblDescription" runat="server" Text='<%# Bind("Comment") %>' meta:resourcekey="lblDescriptionResource1"></asp:Label>
                    </ItemTemplate>
                    <ItemStyle CssClass="gridText tenXPadding rightBorder bottomBorder" Wrap="True" Width="35%"
                        VerticalAlign="Top" />
                </asp:TemplateField>
                <asp:CommandField ButtonType="Button" ItemStyle-CssClass="tenXPadding bottomBorder"
                    ShowEditButton="True" ControlStyle-CssClass="buttonEnabled" ItemStyle-VerticalAlign="Top"
                    HeaderStyle-BorderColor="White" HeaderStyle-BorderWidth="0" HeaderStyle-BorderStyle="None"
                    ItemStyle-Width="20%" meta:resourcekey="CommandFieldResource1">
                    <ControlStyle CssClass="buttonEnabled"></ControlStyle>
                    <HeaderStyle BorderColor="White" BorderWidth="0px" BorderStyle="None"></HeaderStyle>
                    <ItemStyle VerticalAlign="Top" CssClass="tenXPadding bottomBorder" Width="20%"></ItemStyle>
                </asp:CommandField>
            </Columns>
        </asp:GridView>

In the above code you can see there is a GridView control which has its columns bound to various properties like “Key”, “Value” and “Comment”. This is a simple grid with “Edit”, “Update” and “Cancel” facility. In the above HTML make sure you have the “Key” field. “Key” field is used to search the resource file for the record to be updated. Make sure the “Key” field is not editable.

In the Page_Load event in the code behind the following code is used to read the content of a resource file and data bind the same to a GridView control.

protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
LoadData();
}

private void LoadData()
{
   string path = Server.MapPath("App_LocalResources/Default.aspx.resx");
   //Loading the XML file using the Load method of XElement.
   XElement resourceElements = XElement.Load(path);
   //LINQ to load the resource items
   gvResourceEditor.DataSource = (from resElem in resourceElements.Elements("data")
       select new
       {
           Key = resElem.Attribute("name").Value,
           Value = HttpUtility.HtmlEncode(resElem.Element("value").Value),
           Comment = resElem.Element("comment") != null ?
                HttpUtility.HtmlEncode(resElem.Element("comment").Value) : string.Empty
       });
    gvResourceEditor.DataBind();
}

In the above code you can see we are making use of XML to LINQ to read the contents from a resource file (Default.aspx.resx). Once we have loaded the resource file using the Load method of XElement class, in the next line we are making use of LINQ and creating anonymous types and assigning the same as DataSource to the GridView control.

With that simple code we have read the contents from a resource file and displayed the same in a GridView with facility to “Edit”, “Update” and “Cancel”. Now lets see how to update a particular value in a resource file.

Updating a resource file

In the “RowUpdating” event of the GridView control we are doing the following to update the resource file.

protected void gvResourceEditor_RowUpdating(object sender, GridViewUpdateEventArgs e)
{
    string theFileName = Server.MapPath("App_LocalResources/Default.aspx.resx");
    Label lblKey = gvResourceEditor.Rows[e.RowIndex].FindControl("lblKey") as Label;
    TextBox txtValue = gvResourceEditor.Rows[e.RowIndex].FindControl("txtValue") as TextBox;
    TextBox txtComment = gvResourceEditor.Rows[e.RowIndex].FindControl("txtComment") as TextBox;
    //Loading the Resource file as an XML.
    XDocument xDoc = XDocument.Load(theFileName);
    //Filtering out key which matches currently updated record.
    var elementToBeEdited = from xle in xDoc.Element("root").Elements("data") where xle.Attribute("name").Value == lblKey.Text select xle;

    if (elementToBeEdited != null && elementToBeEdited.Count() > 0)
    {
        //Updating the new value
        elementToBeEdited.First().SetElementValue("value", HttpUtility.HtmlDecode(txtValue.Text));

        //Checking if there is a comment node, if no then adding a new comment node.
        if (elementToBeEdited.First().Element("comment") == null && !string.IsNullOrEmpty(txtComment.Text))
        {
            elementToBeEdited.First().Add(new XElement("comment", HttpUtility.HtmlDecode(txtComment.Text)));
        }
        else if (elementToBeEdited.First().Element("comment") != null && !string.IsNullOrEmpty(txtComment.Text))
        {
            //If comment node is present then updating the comment node.
            elementToBeEdited.First().SetElementValue("comment", HttpUtility.HtmlDecode(txtComment.Text));
        }
        //Finally saving the Resource file.
        xDoc.Save(theFileName);
    }

gvResourceEditor.EditIndex = -1;
LoadData();
}

In the above code, first we are finding controls holding the values and then we are loading the resource file into the XDoc object. Once the resource file is loaded, in the next line we are making use of LINQ statement to select the element whose name attribute matches the “Key” field of the GridView. Once the element to be edited is filtered next we are updating the “value” node with the newly updated value. The value node in the resource file holds the text.

Then in the next line we are checking whether there is a comment node available, if not we are creating a new comment node by calling the “Add” method and passing a new “XElement” object as the parameter. If there is a comment node then we are updating the comment by calling the “SetElementValue” method and passing the necessary text as argument. Finally the updated resource file is saved by calling the “Save” method of the XDoc class.

Isn’t it so simple to update the resource file. With XML to LINQ the code has become terse and very easy. So with this you have seen how to read and update a resource file using LINQ.

Note: If you are updating a resource file in a live system then keep in mind that all the logged in users session will expire and they will be logged out.

Try to konw more…

Sandeep

Calling multiple validation group

2009-09-27T14:14:00.001+05:30

Recently I had this requirement where in a single button click I need to call multiple Validation groups. The scenario is something like this. I had a ASP.NET page where there were 5 user controls and each had their own validation controls embedded in them. Each user control had its own validation controls and they had their own Validation group defined. All these user controls were placed in a single page which only had two button “Submit” and “Canel”. On click of the “Submit” button all the validation controls in the form should execute. The problem here is that there are five different validation groups in the same page. To top it all you can only assign one validation group to a button’ ValidationGroup property. If you don’t assign any validation group then on click of the submit button the validation controls which don’t have any validation group defined for them will only be fired. Validation controls which have validation group property defined will not get fired. This is the default behavior of validation controls. So how to call the validation controls of different groups? The answer lies in calling the “Page_ClientValidate” javascript method with the validation group name.

Lets try to understand how this all words with some code.The HTML code of the page looks something like this.

From the above markup you can make out that there are four required field validators and out of the four validators three have validation group property defined. In such a scenario when you click the submit button only the validator which doesn’t have validation group will be executed i.e. RequiredFiedlValidator4 will only be executed. Since there are more than one validation group assigning button’ ValidationGroup wont work as it will execute only validator controls which belong to the assigned validaiton group. Other validator controls belonging to other validation group won’t execute. Also there is no way to specify multiple validaiton group using the ValidationGroup property of the button control.

The way to solve this problem is to call Page_ClientValidate javascript function. Page_ClientValidate is a javascript function generated by ASP.NET. The function takes validation group name as an argument. The javascript function which gets called when the submit button is clicked is pasted below.

In the above code you can see the Page_ClientValidate function is called four times, first by passing the first validation group name, second time passing on the second validation group name and so on. If you see the last call to Page_ClientValidate, it is called with an empty argument. When call Page_ClientValidate with no argume/validation group name it executes all the validation controls in the page which don’t have a validation group assigned to them. So if one wants to execute validation controls which are not having any validation group associated with them you can call the Page_ClientValidate without any parameter.

So using Page_ClientValidate javascript function one can execute all the validation controls in the page by passing the validation group name or without any validation group name.

Try to know more.

Sandeep

Some important .NET functions. Part – 1

2009-09-19T22:37:00.001+05:30

.NET is a big ocean. Each day when I work I find one or the other function which are very useful in day to day programming. So I thought I will start a series of blog on some .NET function which I feel are very useful. Here is the first list of function.

Recently while working in a ASP.NET project I wanted to make use of colors given by the designers in C# code behind file and wanted to change the color of ASP.NET controls. You will be thinking what is so hard in this. There is nothing much other than the color was given in hexadecimal value, like #657468, #AA3212 etc, and .NET controls only understand System.Drawing.Color structure values. So there is my problem. I need to convert the hexadecimal values to System.Drawing.Color values. Luckily I didn’t had to break my head for solving this problem, .NET provides a class just to solve my problem. The class is called ColorTranslator. The method which helped me is FromHtml. Code is pasted below.

DropDownList1.BackColor = System.Drawing.ColorTranslator.FromHtml("#345678");
DropDownList1.BorderColor = System.Drawing.ColorTranslator.FromHtml("Yellow");

The FromHtml method can take the name of the color as well as the hexadecimal value/HTML value. Some other methods of the class are listed below.

ColorTranslator.ToHtml(Color theColor): This is just the opposite of FromHtml i.e. it converts the color to HTML values. So when one wants to convert color to HTML color values/Hexadecimal color value one can make use of the ToHtml method. Sample code is pasted below.

DropDownList1.BackColor =
System.Drawing.ColorTranslator.FromHtml("#ff5678");
DropDownList1.BorderColor =
System.Drawing.ColorTranslator.FromHtml("Yellow");
Console.WriteLIne(System.Drawing.ColorTranslator.ToHtml
(DropDownList1.BackColor));//Output - #ff5678
Console.WriteLine(System.Drawing.ColorTranslator.ToHtml
(DropDownList1.BorderColor));//Output - Yellow

ColorTranslator.ToWin32(Color c) and ColorTranslator.FromWin32(int w32): ToWin32 converts the Color object to the equivalent windows color value whereas FromWin32 does just the opposite i.e. converts a Win32 color value to a System.Drawing.Color object. Sample codes are pasted below.

Console.WriteLine(System.Drawing.ColorTranslator.ToWin32
(System.Drawing.Color.Red));//Output – 255.
System.Drawing.Color color =
System.Drawing.ColorTranslator.FromWin32(255);

ColorTranslator.ToOLE(Color col) and ColorTranslator.FromOLE(int oleValue): ToOLE method converts Color object to OLE equivalent color value and FromOLE converts OLE color value to System.Drawing.Color object.

My ever useful System.IO.Path class

Over my career the class which is mostly used by me is the System.IO.Path class. Though the class has got only 15 or so static methods I use this class a lot while working with file paths. Let me first start with my favorite Combine method of the Path class which I use the most.

Path.Combine(string path1, string path2): The combine method combines two paths and returns you the combined path. The method takes care to add the necessary directory separator before combining the two paths. Also the combine method can be used to combine paths with wild characters like *.pdf or sa*.txt etc. If wild characters are used the combine method takes them as search criteria and doesn’t throw any error. E.g pasted below.

System.IO.Path.Combine(Server.MapPath("."), "images")
//Output: "C:\\aaa\\bb\\WebSite1\\images"
System.IO.Path.Combine(System.IO.Path.Combine(Server.MapPath
("."), "images"), "*.gif")
//Output: "C:\\aaa\\bb\\WebSite1\\images\\*.gif"

Path.GetExtension(string thePath): The GetExtension method returns the extension along with “.” from the path argument passed. So if you want to retrieve only extension from a file path just pass the file path to the GetExtension method and there you go you will have your extension. GetExtension method returns an empty string if the path doesn’t have any extension, also it returns null if the path argument is null. E.g. pasted below.

string filePath = System.IO.Path.Combine(System.IO.Path.Combine(Server.MapPath
("."), "images"), "*.gif");
Console.WriteLine(System.IO.Path.GetExtension(filePath));
//Output: .gif

Path.GetFileName(string thePath): This method returns the filename with extension from the specified path argument. Returns an empty string if there are no file name. Sample code is pasted below.

string filePath = System.IO.Path.Combine(System.IO.Path.Combine(Server.MapPath
("."), "images"), "tick.gif");
Console.WriteLine(System.IO.Path.GetFileName
(filePath));//Output: tick.gif

Path.ChangeExtension(string filePath, string newExt): This method changes the extension of the file. The method takes two arguments, filename with extension along with/without path and second one is the new extension with “.” which needs to be applied. If period is not there in the new extension argument then the method adds one. If you just wants to remove the extension then just pass a null value as the new extension parameter. Sample code is given below.

string filePath = System.IO.Path.Combine(System.IO.Path.Combine(Server.MapPath
("."), "images"), "tick.gif");
Console.WriteLine(System.IO.Path.ChangeExtension
(filePath, "jpg"));//Output: C:\\aaa\\bb\\WebSite1
\\images\\tick.jpg

Path.GetFileNameWithoutExtension(string filePath): Function returns the file name without extension. E.g. is shown below.

string filePath = System.IO.Path.Combine(System.IO.Path.Combine(Server.MapPath
("."), "images"), "tick.gif");
Console.WriteLine(System.IO.Path.ChangeExtension
(filePath, "jpg"));//Output: tick

Path.GetRandomFileName(): Returns a random string. The string is generated using cryptographic principles. The string can be used as folder or file name. Sample code is pasted below.

Console.WriteLine(System.IO.Path.GetRandomFileName())//Output: x4zxg224.hva

Path.GetTempFileName(): Function returns a string with a file name along with temporary folder path. The filename returned has a .tmp extension. The method creates a file with .tmp in the temporary folder and then returns the filename along with the temprorary folder path where the file is created. Sample code with output is pasted below.

Console.WriteLine(System.IO.Path.GetTempFileName())//Output: C:\\Documents and Settings\\sandeep\\Local Settings\\Temp\\tmp20C.tmp

Path.GetTempPath(): GetTempPath function returns the system’ temporary folder path. Sample code is pasted below.

Console.WriteLine(System.IO.Path.GetTempPath());//Output: C:\\Documents and Settings\\sandeep\\Local Settings\\Temp\\

Path.HasExtension(string filePath): This function checks whether the file path passed has a file extension. If extension is found the function returns true else false.

So these are some of my favorite and useful functions. Will publish some more over the course of time till then try to know more.

Sandeep

Saving files from one website to another website.

2009-08-31T14:37:00.001+05:30

This blog is based on my recent requirement where I had to save some image files from one website to another website. Lets see the requirement and the solution for the requirement.

Requirement

The requirement is as follows. The user will select a file which needs to be uploaded using a website (UploadFilesWebsite) and these selected files will be saved in another website (SaveFilesWebsite). Cross website posting of data. We all know it’ very easy to save files within the same site by making use of a file upload control and calling its SaveAs method. E.g. is pasted below.

fileUploadCntl.SaveAs(System.IO.Path.Combine(Server.MapPath("."), fileUploadCntl.FileName))

But in my case it was different, the file needs to be saved in a different website from the one from where file upload is done.

Solution

The problem was solved by making use of HttpWebRequest and HttpWebResponse object. Below is steps which are needed to solve this problem.

First create an ASPX file which will be capable of receiving any type of file stream and saving this stream to the required folder. This file should be created/placed in the website where you want to save the files, in my case it is “SaveFiles” website.
Create a HttpWebRequest object and pump the file content to the RequestStream of the HttpWebRequest object.
Get the response using the GetResponse method of the HttpWebRequest object. GetResponse will return a HttpWebResponse object.
Get the response stream from the HttpWebResponse object by executing the GetResponseStream method.

These are the steps which you need to follow to post file contents from one website to another. Lets see each one of these one by one.

Create an aspx file capable of saving request stream.

The first step is to create an aspx file which will be capable of saving a request stream. This file should be created and saved in the web site where you plan to save your file. This file will receive requests from other website for saving files in the website. So we will create this file in “SaveFiles” website and we will name it as SaveFile.asxp. After creating and saving the file go to the HTML source view of the file. It will look something like this.

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

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
    <title>Untitled Page</title>
</head>
<body>
    <form id="form1" runat="server">
    <div>
    </div>
    </form>
</body>
</html>

Remove the HTML source from the file leaving only the Page attribute. The page should look something like this.

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

Now lets go to the codebehind and do some coding to save the request stream. The codebehind (SaveFile.aspx.cs) file of SaveFile looks something like this.

using System;
using System.Configuration;
using System.Data;
using System.Linq;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.HtmlControls;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Xml.Linq;

public partial class SaveFile : System.Web.UI.Page
{
    protected void Page_Load(object sender, EventArgs e)
    {
        try
        {
            /*Retrieving the file name from the headers in the request. */
            string fileName = System.IO.Path.Combine(Server.MapPath("."), Request.Headers["FileName"].ToString());
            using (System.IO.FileStream fileStream = System.IO.File.Create(fileName))
            {
                /*Getting stream from the Request object.*/
                using (System.IO.Stream stream = Request.InputStream)
                {
                    int byteStreamLength = (int)stream.Length;
                    byte[] byteStream = new byte[byteStreamLength];
                    /*Reading the stream to a byte array.*/
                    stream.Read(byteStream, 0, byteStreamLength);
                    /*Writing the byte array to the harddisk.*/
                    fileStream.Write(byteStream, 0, byteStreamLength);
                }
            }
            Response.Clear();
            /*Writing the status to the response.*/
            Response.Write("File successfully saved");
        }
        catch (Exception ex)
        {
            /*Writing the error message to the response stream.*/
            Response.Clear();
            Response.Write("Error: " + ex.Message);
        }
    }
}

From the above code one can see we are first retrieving the filename from Request object’ Headers property. We will shortly see how to send info in headers of a request. After getting the filename we are opening a file stream to flush the content to the hard disk. Once the file stream is successfully created, next, we are creating a stream by getting the InputStream of the Request object. The InputStream property of the Request object will hold the content which needs to be saved. In the next line we are reading the stream content to a byte array and finally passing the byte array to the FileStream object and writing/saving to a file. Once the file is successfully saved we are writing the status to the Response after clearing the Response. Also if there is any exception thrown while the file is saved the same is written to the Response.

So that’ about the page which will save the content in the desired filename. So now we will move to our next steps like creating the HttpWebRequest object and passing the file content to the SaveFile.aspx file to save it in the website.

Create an aspx page to upload the images.

The file which we will be creating will have the capability to upload files from the user’ hard disk and will send these file contents to the SaveFile.aspx page. The UploadFile.aspx will be created in a separate website/virtual directory called “UploadFiles” website. This aspx page will have a FileUpload control and a save button. So here is the HTML source of UploadFile.aspx.

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

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
    <title>Untitled Page</title>
</head>
<body>
    <form id="form1" runat="server">
    <div>
    </div>
       <asp:Label ID="lblMessage" runat="server"></asp:Label><br />
        <asp:FileUpload ID="fileUpload" runat="server" /><br />
        <asp:Button ID="btnSave" runat="server" Text="Save Files"
        onclick="btnSave_Click" />
    </form>
</body>
</html>

From the HTML you can see that we have an FileUpload control and a save button with an OnClick event handler. So that’ our simple UploadFile page. Now lets see the real action i.e. the place where the code to upload files and sending the content of these files to the SaveFile.aspx in “SaveFiles” website happen. So here is the click event of the save button where all the action takes place.

protected void btnSave_Click(object sender, EventArgs e)
{
        /*Creating the WebRequest object using the URL of SaveFile.aspx.*/
        System.Net.HttpWebRequest webRequest =
(System.Net.HttpWebRequest)System.Net.HttpWebRequest.Create
("Http://Localhost/SaveFiles/SaveFile.aspx");
        webRequest.Method = "POST";
        webRequest.KeepAlive = false;
        /*Assigning the content type from the FileUpload control.*/
        webRequest.ContentType = fileUpload.PostedFile.ContentType;
        /*Creating the Header object.*/
        System.Net.WebHeaderCollection headers = new System.Net.WebHeaderCollection();
        headers.Add("FileName", fileUpload.FileName);
        /*Adding the header to the WebRequest object.*/
        webRequest.Headers = headers;
        /*Getting the request stream by making use of the GetRequestStream method of WebRequest object.*/
        using (System.IO.Stream stream = webRequest.GetRequestStream())//Filling request stream with image stream.
        {
            /*Writing the FileUpload content to the request stream.*/
            stream.Write(fileUpload.FileBytes, 0, fileUpload.FileBytes.Length);
        }
        /*Creating a WebResponse object by calling the GetResponse method of WebRequest object.*/
        using (System.Net.HttpWebResponse webResponse = (System.Net.HttpWebResponse)webRequest.GetResponse())
        {
            /*Retrieving the response stream from the WebResponse object by calling the GetResponseStream method.*/
            using (System.IO.StreamReader sr = new System.IO.StreamReader(webResponse.GetResponseStream()))
            {
                lblMessage.Text = sr.ReadToEnd();
            }
        }
}

In the above code first I am creating a WebRequest object by passing the URL of the page which will handle the saving mechanism. Once the WebRequest object is created next I am assigning the Method as POST. This is a very important step. If you don’t assign the method property it will default to “GET”. If you use “GET” as the method to send data then you will receive System.Net.ProtocolViolationException with the following message.

"Cannot send a content-body with this verb-type."

Once the method is set to “POST” we are setting the KeepAlive property to false. KeepAlive property will be responsible for maintaining a live connection. The next line we are setting the ContentType of the request. The content type can be easily retrieved by calling the ContentType property from PostedFile property of the FileUpload Control. Next line we are creating a WebHeaderCollection object to pass additional information in the headers of the request. You can see we are passing the file name as one of the header value. These header details are read in SaveFile.aspx. So if you want send some extra information you can do that using WebHeaderCollection. In the next few lines we are retrieving the request stream using the GetRequestStream method and then writing the contents of the selected file to request stream using the Write method of the Stream object. To pump the content of the chosen file we are making use of the FileBytes property of the FileUpload control. One can note that we are making use of the “using” statement quite a lot. To know more about the usefulness of the “using” statement you can refer my blog on using statement here.

Once the FileUpload contents are pumped to the request stream of the HttpRequest object in the next line I am creating the HttpWebResponse using the GetResponse method of the HttpWebRequest object. So what GetResponse does is that it sends a request to the Url (savefile.aspx) specified while creating the HttpWebRequest object. When the HttpWebRequest object sends request to the url its similar to the way we access url through the browser. So the whole life cycle of the page executes and response is saved in the form of HttpWebResponse object. After getting the HttpWebResponse object we are reading what output was returned by the page using the StreamReader object’ ReadToEnd method. You can retrieve the StreamReader object by calling the GetResponseStream method of the WebRequest object. The response which I am getting is directly assigned to the Text property of a label control. What we get in the ResponseStream object is what we have written to the response using the Write method of the Response property in the SaveImage.aspx page. So if the image is successfully saved we get “File Successfully saved” as the response else we get error as the response.

That’ it, we are done. With this technique we can save files or contents from one website to another site i.e. cross website posting of data. This technique is very simple but can be very dangerous. You should make sure that you implement some sort of authentication so that hackers can be evaded from saving some malicious files.

Try to know more.

Sandeep

Creating RESTful web services in .NET

2009-08-10T19:48:00.001+05:30

This blog is about creating RESTful web services using Windows Communicaiton Foundation (WCF) in .NET. The intention of this blog is not to teach what is Representation State Transfer (REST) but how to create web services which support REST by making use of WCF. So lets start by having a look at what was the requirement which prompted me to create a RESTful web service and how we did it.

As with any change in software, this change, to have RESTful web service was also raised by the client. The client in our case had some Business Access Layer (BAL) and he wanted to expose some of the methods to the outside world through RESTful web service. So what we did was we created a Facade layer to expose the required methods of the BAL and called exposed this Facade layer with the help of WCF web service. Thats the simple solution to our requirement. Now lets see the code wise implementation of the solution.

As per company rules and other client agreement I may not be able to publish the same implementation but will try to take another e.g. and try to replicate the same scenario and create RESTful web services. We will see two ways of creating WCF, one is implementing the interface in class file and then exposing the class methods using a .SVC file and second approach is the default way i.e. implementing an interface to a .SVC file. Lets see the first way (this was the solution implemented to solve our problem).

For creating a WCF service first thing you need is a contract. A contract is nothing but an Interface with the methods you want to expose. So lets create our contract (interface) which will be implemented by the WCF service. Any WCF webservice (RESTful or non RESTful) needs a contract, if no contract is defined then the class should be have the ServiceContract attribute to it and this is mandatory. Below is the interface definition.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace CarService
{
    [System.ServiceModel.ServiceContract]
    public interface ICarService
    {
       [System.ServiceModel.OperationContract]
       [System.ServiceModel.Web.WebGet(UriTemplate="cars",
         ResponseFormat = System.ServiceModel.Web.WebMessageFormat.Xml)]
        List<Car> GetCars();

       [System.ServiceModel.OperationContract]
       [System.ServiceModel.Web.WebGet(UriTemplate="cars/search?carName={theCarName}")]
        Car GetCar(string theCarName);
    }
}

From the above interface definition one can see that we are using some attributes. Lets see each of these attributes one by one. First up is the ServiceContract attribute.

ServiceContract: This attribute tells the system that the interface defines a service contract for a WCF application. If an interface which is being inherited by a WCF web service doesn’t have a ServiceContract attribute then the following error will thrown by the system.

Service 'CarService' implements multiple ServiceContract types, and no endpoints are defined in the configuration file. WebServiceHost can set up default endpoints, but only if the service implements only a single ServiceContract. Either change the service to only implement a single ServiceContract, or else define endpoints for the service explicitly in the configuration file.

Just applying the ServiceContract attribute above the interface will solve the above error. Now lets see the various properties associated with the ServiceContract attribute

Property	Description
ConfigurationName	The element name in the configuration file which defines the service.
Name	Using the property you can provide a different name to the interface.
Namespace	Can be used to provide namespace.
ProtectionLevel	enum value specifies what type of protection should be applied to the service. The enum values are ProtectionLevel.None, ProtectionLevel.Sign and ProtectionLevel.EncryptAndSign
SessionMode	enum specifies whether sessions are allowed or not. The enum values are SessionMode.Allowed, SessionMode.Required and SessionMode.NotAllowed.

That’ about ServiceContract attribute. The next attribute which we have used in all the methods is the OperationContract attribute. Lets see what does OperationContract do.

OperationContract: OperationContract attribute tells the system that the method needs to be exposed as part of a service contract. A method which is not having OperationContract will not be exposed. So its imperative to have OperationContract attribute to expose a method. The properties which can be used along with OperationContract are.

Property	Description
Action	Using the action property you can specify a url to which the incoming messages needs to be posted. Action uniquely identifies a method with a Url.
AsyncPattern	Specifies whether the method can be called asynchronously or not.
IsOneWay	Specifies whether the operation returns a value or not.
IsInitiating	Specifies whether the method needs to be called when session is started.
IsTerminating	Tells the system to execute the method when session is completed.
Name	If you want to give some other name to the method then you can make use of the name property.
ProtectionLevel	enum value specifies what type of protection should be applied to the service. The enum values are ProtectionLevel.None, ProtectionLevel.Sign and ProtectionLevel.EncryptAndSign

Next attribute which you will notice is the WebGet. Here is the explanation of WebGet attribute.

WebGet: If you would have worked on ASP.NET application then you know that the forms in ASP.NET post data in two ways, one is the GET method and the other one is the POST method. WebGet attribute tells the system that the method is a pure data retrieval method to which HTTP GET method is associated. The properties associated with WebGet are listed below.

Property	Description
BodyStyle	enum specifies how messages should be sent. Enum values are WebMessageBodyStyle.Bare, WebMessageBodyStyle.Wrapped, WebMessageBodyStyle.WrappedRequest and WebMessageBodyStyle.WrappedResponse.
RequestFormat	enum specifies what is the request format. Enum values are WebMessageFormat.Xml and WebMessageFormat.Json.
ResponseFormat	Same as RequestFormat. Specifies the type of the response.
UriTemplate	The Uri to access the method/operation.

UriTemplate here is the endpoint. Here endpoint means a unique Url to access the method in a restful webservice. This is one of the requirement of a RESTful method which says there should be unique endpoint to access the methods.

One thing to note in UriTemplate property is that whatever you specify inside a curly brace, {}, and if the same name is used in the parameter of the method then the value which comes in the querystring is passed on as the parameter for the method. In our second method in the interface we have given the UriTemplate as something like this “cars/search?carName={theCarName} ” which means the querystring value in carName will be passed as the parameter to the method, as the parameter name and value inside the curly brace are the same. If you want more parameters you can very well do this by declaring more parameters in the querystring. A hypothetical method is pasted below.

[System.ServiceModel.OperationContract]
[System.ServiceModel.Web.WebGet(UriTemplate = "cars/Carsearch?carName={theCarName}&color={theColor}&price={thePrice}")]
Car SearchCar(string theCarName, string theColor, string thePrice);

In the above e.g. theCarName, theColor and thePrice will be passed as parameter to the method SearchCar. The url may look something like this “http://localhost:2333/cars/carsearch?carName=ferrari&color=red&price=432544”. The values ferrari, red and 432544 will be passed as parameters to the SearchCar method. So if you want to pass parameters to a RESTful web method then you need to just follow the above approach.

Now that was about making use of HTTP GET method. The next obvious question would be how to make use of HTTP POST method. To make use of HTTP POST method one need to apply another attribute called “WebInvoke” All the properties are same as in WebGet except for an extra property called Method. Using the method property you can specify the HTTP method like POST, PUT, DELETE and HEAD. When to use each of these HTTP method is given below.

HTTP Method	Description
GET	Whenever you want to retrieve some information you will make use of get.
POST	When you want to submit data which will be processed by the service.
PUT	When you want create or update a resource you will make use of PUT.
DELETE	As the name suggest whenever you want to delete a resource you will make use of DELETE.

Now we have our contract defined. So the first step is over. Now we need to implement the interface and that is what we are going to do next. We will be implementing the interface in a class called CarService. The code is pasted below.

namespace CarService
{
    public class CarService : ICarService
    {
        List<Car> carList;
        public CarService()
        {
            carList = new List<Car> {new Car{ModelName="Ferrari", Color="Ferrari Red", CubicCentimeter= "2345",
             Price=34324324}, new Car{ModelName="BMW 3 Series", Color="Blue", CubicCentimeter= "2200",
             Price = 32423}, new Car{ModelName="Benz SLR", Color="Milky White", CubicCentimeter = "3200",
             Price = 32424}};//Storing the car objects in a collection
        }
        List<Car> ICarService.GetCars()
        {
            return carList;
        }

        Car ICarService.GetCar(string theCarName)
        {
            var car = from c in carList where c.ModelName == theCarName select c;
            Car cs = null;
            foreach (var c in car)
            {
                cs = c as Car;
            }
            return cs;
        }
    }
}

You can see from the above code we have implemented ICarService interface into a class called CarService. The first method returns the Car collection and the second method searches the carList collection object based on the name of the car and returns the matching Car object. No rocket science here. The Car class is discussed in detail at the end of the blog. So we will move on to the next step.

We have defined the base requirement and now we have to expose the methods to the outside world using WCF service. For that you can either add a new WCF Service Applicaiton project from the file menu or you can right click on your ASP.NET or web service project and from the popup menu select Add—>New Item option. From the Add New Item dialog box select WCF Service and give a name to your service. I have named it CarService. The screenshot of Add New Item dialog is pasted below.

You can do the same from file menu as well.

When you add WCF Web service application or a SVC file the system will automatically add an interface by the name ICarService or I followed by whatever name given to the project or SVC file. Delete the interface, as we have already defined the contract. Also delete the SVC.cs file. Now open the SVC file, in my case CarService.svc. You can see a markup something like this.

<%@ ServiceHost Language="C#" Debug="true" Service="CarService.CarService" CodeBehind="Service1.svc.cs" %>

Delete the CodeBehind attribute and add Factory attribute as shown below.

<%@ ServiceHost Language="C#" Debug="true"
Service="CarService.CarService" Factory="System.ServiceModel.Activation.WebServiceHostFactory" %>

You may get an error something like the one pasted below.

Service 'CarService.CarService' has zero application (non-infrastructure) endpoints. This might be because no configuration file was found for your application, or because no service element matching the service name could be found in the configuration file, or because no endpoints were defined in the service element.

If you come across an error like this then the possible reason could be you will be missing the Factory attribute in the ServiceHost tag. Just by adding the Factory attribute will solve the prob.

Visual studio also embeds the following tag in Web.config file.

<system.serviceModel>
        <behaviors>
   <serviceBehaviors>
    <behavior name="RestFulWebservice.CarServiceBehavior">
     <serviceMetadata httpGetEnabled="true" />
     <serviceDebug includeExceptionDetailInFaults="false" />
    </behavior>
   </serviceBehaviors>
</behaviors>
        <services>
   <service behaviorConfiguration="RestFulWebservice.CarServiceBehavior"
    name="RestFulWebservice.CarService">
    <endpoint address="" binding="wsHttpBinding" contract="CarService.ICarService">
     <identity>
      <dns value="localhost" />
     </identity>
    </endpoint>
    <endpoint address="" binding="mexHttpBinding" contract="IMetadataExchange" />
   </service>
</services>
</system.serviceModel>

Now you are ready to go. Just hit F5 and see the output. If you see a message saying there is no endpoint defined you need not panic. Just type one of the endpoints defined in the contract (interface) you can see the output. In my case the two url which I used are as follows.

http://localhost:3891/CarService.svc/cars
Ouput of the above url

<GetCarsResponse xmlns="http://tempuri.org/">
     <GetCarsResult xmlns:a="http://schemas.datacontract.org/2004/07/CarService" xmlns:i="http://www.w3.org/2001/XMLSchema-instance">
         <a:Car>
          <a:Color>Ferrari Red</a:Color>
          <a:CubicCentimeter>2345</a:CubicCentimeter>
          <a:ModelName>Ferrari</a:ModelName>
          <a:Price>34324324</a:Price>
          </a:Car>
         <a:Car>
          <a:Color>Blue</a:Color>
          <a:CubicCentimeter>2200</a:CubicCentimeter>
          <a:ModelName>BMW 3 Series</a:ModelName>
          <a:Price>32423</a:Price>
          </a:Car>
         <a:Car>
          <a:Color>Milky White</a:Color>
          <a:CubicCentimeter>3200</a:CubicCentimeter>
          <a:ModelName>Benz SLR</a:ModelName>
          <a:Price>32424</a:Price>
          </a:Car>
      </GetCarsResult>
</GetCarsResponse>

http://localhost:3891/CarService.svc/cars/search?carName=Ferrari

Output of the above url.

<Car xmlns="http://schemas.datacontract.org/2004/07/CarService" xmlns:i="http://www.w3.org/2001/XMLSchema-instance">
<Color>Ferrari Red</Color>
<CubicCentimeter>2345</CubicCentimeter>
<ModelName>Ferrari</ModelName>
<Price>34324324</Price>
</Car>

The car class which is getting serialized is shown below.

[System.Runtime.Serialization.DataContract]
public class Car
{
        [System.Runtime.Serialization.DataMember]
        public string Color
        { get; set; }
        [System.Runtime.Serialization.DataMember]
        public string ModelName
        { get; set; }
        [System.Runtime.Serialization.DataMember]
        public int Price
        { get; set; }
        [System.Runtime.Serialization.DataMember]
        public string CubicCentimeter
        { get; set; }
}

The objects used in WCF should be qualified by DataContract attribute. Some of the properties of DataContract are listed below.

Property	Description
Name	If you want to give a different name to the class when it is serialized then you can make use of the name property.
Namespace	To provide a namespace to the xml attribute you can make use of the “Namespace” property. When you provide namespace it has abide by w3 guidelines. As a general practice we provide urls as namespace.

The other attribute is the DataMember. DataMember attribute tells the serializer that the property/field is part of a DataContract and it can be serilizable. Some of the properties are explained below.

Property	Description
EmitDefaultValue	Property which tells the serializer whether to emit default value if the property is not having any value.
IsRequired	This property can be set when you want the property/field to be present while serializing and deserializing the object.
Name	If you want to give some other name other than name of the property/field then you can make use the Name property.
Order	When the object is serialized in what order the property/field needs to be serialized.

Now lets see the second way of implementing the WCF webservice. This is the most common way which everyone will be aware off. Open VS 2008 and add a new project of type WCF Service Application from File—>New—>Project menu. This will automatically add a contract (interface) and the necessary .SVC files (a .svc and a .svc.cs file inheriting from the interface). Rest we need to follow the same steps for defining various methods in the Interface as explained above.

Formatting numeric data types in .NET

2009-08-08T17:50:00.001+05:30

Recently I was discussing with one of my friend and he informed me that he was breaking his head on creating a utility to format decimals, float and other datatypes. Out of curiosity I asked him how are you doing these, for e.g. displaying a decimal datatype with only two decimal place value. Bang came the reply that he is doing some string manipulation. I was surprised and informed him that he need not take so much of a pain instead he can use ToString methods of most of the datatype to format the data types. In this blog I will highlight some of the commonly needed number formatting techniques.

First up formatting for decimal places.

This is one of the common requirement where we always come across situation to format float, decimal and double datatypes to some number of decimal places. One of the easiest way to format is given below.

double doub = 8457.3299;
float fl = 28398.39843289f;
decimal dec = 982389.348093m;
Console.WriteLine(doub.ToString(".00"));//Output: 8467.33
Console.WriteLine(fl.ToString(".000"));//Output: 28398.400
Console.WriteLine(dec.ToString(".0000"));//Output: 982389.3481

In the above e.g. I have used zero in combination with decimal symbol to format the numbers according to the required precision required. If the need is to format to the max of two decimal places I have used “.” (dot) followed by 2 zeroes. Similarly how many precision points you want you can use that number of zeroes along with dot. Isn’t it so simple? One thing to note here is that the system will automatically round off the numbers if there are more decimal places than what is specified in the format string as you can see in the above e.g.

Formatting numbers

Some number formatting e.g. are given below.

double doub = 8457.3299;
float fl = 28398.39843289f;
decimal dec = 982389.348093m;
Console.WriteLine(doub.ToString("000"));//Ouput 8457
Console.WriteLine(fl.ToString("00000000"));//Ouput 00028398
Console.WriteLine(dec.ToString("00000.000"));//Ouput 982389.348
Console.WriteLine(dec.ToString("00 - 00 - 0.000"));//Ouput 982 - 38 - 9.348
Console.WriteLine(dec.ToString("(00000) (00) (0)"));//Ouput (00982) (38) (9)

In the above e.gs we have used zeroes to format numbers. First formatting using 3 zeroes doesn’t do much. It just displays the numbers as it is. The second one with 8 zeroes formats numbers and adds extra zeroes if the number doesn’t have the required digits i.e. in the above e.g. there are only 5 digits and because of formatting applied it adds extra zeroes preceeding the number. Use of zero to format numbers tells the system that even if zero is not a significant number it should display zero. One can use other characters along with zero to format the numbers. Few e.g. have been highlighted above.

Formatting numbers using # symbol

One of the problem while using 0 to format numbers is that it will show the insignificant numbers or club zeroes to fill the gap. To avoid just this you can make use of # symbol in place of 0. To show the difference between # and 0 I have pasted below same e.g. with both the format string.

double twoDeci = 1234.34;
int flo = 2343243;
decimal deci = 23434355.6749m;
Console.WriteLine(twoDeci.ToString("######.####"));\\Output 1234.34
Console.WriteLine(twoDeci.ToString("000000.0000"));\\Ouput 001234.3400
Console.WriteLine(flo.ToString("(####) - (###) - (##)"));\\Output (23) - (432) - (43)
Console.WriteLine(flo.ToString("(0000) - (000) - (00)"));\\Output (0023) - (432) - (43)
Console.WriteLine(deci.ToString(".##"));\\Output 23434355.67
Console.WriteLine(deci.ToString(".00"));\\Output 23434355.67

From the above e.gs one can make out that if you are using 0 as the format string then it adds insignificant zeroes preceding or leading the numbers, whereas # will ignore insignificant zeroes. Also one thing to note is that if you use # with numbers with insignificant zeroes then it will ignore those zeroes whereas 0 will consider the zeroes as significant. The difference is shown below.

float preecedingZeroes = 00034556;
double leadingZeroes = 34345.983000;
Console.WriteLine(preecedingZeroes.ToString("########"));\\Ouput 34556
Console.WriteLine(preecedingZeroes.ToString("00000000"));\\Ouput 00034556
Console.WriteLine(leadingZeroes.ToString("#####.######"));\\Ouput 34345.983
Console.WriteLine(leadingZeroes.ToString("00000.000000"));\\Ouput 34345.983000

From the above e.g. differences are clear that # never takes into consideration the insignificant zeroes even if there is one in the datatype. So if you want the insignificant zeroes to be considered then you need to use 0 instead of #.

Formatting for thousand separator.

Many a times we get numbers from the database without any formatting applied and we may require the numbers to be formatting with thousand separators. Its very easy to apply thousand separators to a number. E.g. are pasted below.

double preecedingZeroes = 345563434;
Console.WriteLine(preecedingZeroes.ToString("#,#"));\\Output 345,563,434
Console.WriteLine(preecedingZeroes.ToString("0,0"));\\Output 345,563,434

The above e.g. makes use of both # and 0 along with “,” sign for thousand formatting. Comma (,) can be used along with other format strings to apply thousand formatting. One thing to note here is that when you apply thousand separator formatting then the system makes use of the system’ culture and thousand separator associated with the culture. If you want to use a specific culture’ thousand separator then you need to provide the culture you want to use along with the “ToString” method. Here are e.g. in Danish and Indian format.

//Applies Hindi-India culture and formats the number based on Indian notations.
Console.WriteLine(preecedingZeroes.ToString("#,#", System.Globalization.CultureInfo.CreateSpecificCulture("hi-IN")));//Ouput 34,55,63,434
//Applies Danish culture and formats the number based on Danish culture.
Console.WriteLine(preecedingZeroes.ToString("0,0", System.Globalization.CultureInfo.CreateSpecificCulture("da-DK")));//Ouput 345.563.434

So you can see from the above e.g. that in the Indian culture the thousand separator used is comma (,) whereas in Danish culture the thousand separator is represented by a dot (.)

One thing to note here is that if you use “,” one after the other without any number formatting characters in between them, then the meaning of comma completely changes. The system consider each comma as 1000 and divides the number to which formatting is applied by 1000. Confused, let me explain with e.g.

double dou = 23432432423;
Console.WriteLine(dou.ToString("#,,"));//Output 23432
Console.WriteLine(dou.ToString("0,,,"));//Output 23

In the above e.g. if you see in the first formatting we have used two commas which means the number “23432432423” will be divided by thousand two times as the number of commas occur two times in the formatting string. Similarly in the second sample code the commas occur thrice so the number will be divided by 1000 three times.

Formatting for positive and negative numbers.

There may situation where you don’t know what type of number you are getting from the database, whether the number is a positive or a negative one. Even the number can be a zero. You would like to apply different formatting for positive number and different formatting for negative number. Also you would like to show zero in a different way. I have faced a similar prob in one of my projects where the client wanted to display a positive symbol enclosed in brackets (+) in front of a positive number, a negative symbol enclosed in brackets (-) in case of negative numbers and a zero enclosed in brackets (0) in the case of zero. If you also face a similar kind of situation you can make use “;” (semi colon) to separate the formatting. Sample formatting code is given below.

double positiveNo = 3746;
double negativeNo = -3435;
double zero = 0;
string formatString = "(+)#;(-)#;(0)";
Console.WriteLine(positiveNo.ToString(formatString));//Output (+)3746
Console.WriteLine(negativeNo.ToString(formatString));//Output (-)3435
Console.WriteLine(zero.ToString(formatString));//Output (0)

In the above e.g. if you notice I have defined the formatting string for positive, negative and zero in the variable “formatString”. Semi colon (;) is used as the separator for the different number format. This is how this works, starting from left in the formatString variable the format string to the left of the first semi colon is considered as the formatting string for positive numbers, and the format string in between the first semi colon and the second semi colon is considered the format string for negative values and the format string to the right of second semi colon is taken as the format string for zeroes.

If you don’t want to give separate formatting for zero then you can just leave the format string after the second semi colon empty i.e. you need to only specify format strings for positive and negative values. In such situation the format string for positive value will be applied to format zeroes. The sample is given below.

double positiveNo = 3746;
double negativeNo = -3435;
double zero = 0;
string formatString = "(+)#;(-)#";
Console.WriteLine(positiveNo.ToString(formatString));//Output (+)3746
Console.WriteLine(negativeNo.ToString(formatString));//Output (-)3435
Console.WriteLine(zero.ToString(formatString));//Output (+)

Multiplying a number by 100.

If you want to multiply a number by 100 one can make use of the % symbol in the format string along with other format strings. Sample code is pasted below.

double dd = .459;
double ddd = 849;
Console.WriteLine(dd.ToString("#%"));//Output 46%
Console.WriteLine(dd.ToString(".#%"));//Output 45.9%
Console.WriteLine(ddd.ToString("#%"));//Output 84900%
Console.WriteLine(dd.ToString("#.#%"));//Output 45.9%
Console.WriteLine(ddd.ToString("0%"));//Output 84900%

You can see from the above e.g. that by using the % sign along with other format strings the number gets multiplied by 100 and % symbol is appended at the end of the number.

Appending currency symbol to a number.

Another common requirement is to append the currency symbol along with numbers. To do just that one can make use of “C” or “c” character in the format string. The e.g. is given below.

double curFor = 329.5943;
Console.WriteLine(curFor.ToString("C"));//Output $329.59
Console.WriteLine(curFor.ToString("C3"));//Output $329.594

The currency symbol and precision points will be taken from the current culture set for the system. If you want to specify precision points for decimal value then you can specify the number of precision points after the “C” symbol as shown in the above e.g. If you want to change the current culture and apply some other culture then you can do that as shown in the below e.g.

Console.WriteLine(curFor.ToString("C3", System.Globalization.CultureInfo.CreateSpecificCulture("en-GB")));//Output £329.594

In the above e.g. we are using currency format specifier with 3 decimal point precision and also we are applying Great Britain’ i.e. UK’ culture. This formats the number and adds the pound symbol.

Displaying numbers in exponential form

If you want to display numbers in exponential format you can make use of “E” or “e”. Sample code is pasted below.

double exp = 43895.04390;
Console.WriteLine(exp.ToString("e"));//Output 4.389504e+004

If you want you can specify the number of precision decimal points to be displayed. If the precision points are not specified then the system by default will add 6 precision points after the decimal point. Sample code with precision point is pasted below.

double exp = 43895.04390;
Console.WriteLine(exp.ToString("E9"));//Output 4.389504390E+004

So with that I have covered some of the common number formatting requirements.

Try to know more.

Sandeep

Lambda Expressions – Features of C# 3.0 (Part – 6)

2009-07-09T18:05:00.001+05:30

In my earlier article we have seen the following new features of C# 3.0.

In this blog we will try to understand the concept of Lambda expressions.

What is Lambda Expression?

Lambda expressions are nothing but anonymous functions. Lambda expressions can be used to write expressions or statements. To write Lambda expression one has to make use of the Lambda operator which is read as “goes to”. Lambda operator is represented as “=>” i.e. an equal to sign followed by a greater than symbol. Lambda expressions normally have input parameters on the left side of the Lambda operator and expressions/statements on the right side. The lambda operator is used to separate the input arguments on the left side from the expression/statements on the right side. Lambda expressions are extensively used in LINQ. An e.g. of Lambda expression is given below.

public class LambdaExpressionDemo
{
    delegate int Add(int a, int b);
    public void PrintAddResult(int num1, int num2)
    {
        Add addResult = (a, b) => a + b;
        Console.WriteLine(addResult(num1, num2).ToString());
    }

    public double CountEmp()
    {
         System.Collections.Generic.List<Person> perColl = new List<Person>{
             new Person {FName="first", LName="lastFirs", Age=30},
             new Person{FName="second", LName="lastSecond", Age=24},
             new Person{FName="third", LName="Third", Age=44}};
            double avgAge = perColl.Count(p => p.LName.StartsWith("la"));
         return avgAge;
     }
}

In the above code one can see we have declared a delegate which returns an integer value and takes two integers as input parameters. Also you can see I have declared a delegate variable (addResult) and assigned an anonymous function using our Lambda expression. One thing to note here is that there is no need to declare the type of the input arguments for the anonymous functions. The compiler will infer the type. What the above lambda expressions means is that we have an anonymous function with two input parameters (left side of the Lambda operators are input parameters) which needs to be added and the result returned. Don’t you thing this is a very simple way of declaring a function. In the second e.g. I have made use of Lambda expression along with Count method. The lambda expression evaluates and checks whether the person’ LName starts with “la” and returns true or false. If it returns true then that record is counted. So the count will be 2.

To better understand the advantages/usefullness of Lambda expression we need to know how we use to implement these things in the earlier versions of C#. Lets see how we would do this in C# 2.0 using anonymous methods.

delegate int Add(int a, int b);
public void PrintAddResult(int num1, int num2)
{
    //Using anonymous methods of C#2.0.
    Add addResult = delegate(int aa, int bb) { return aa + bb; };
    Console.WriteLine(addResult(num1, num2));
}

In the above e.g. we are making use of Anonymous method feature of C# 2.0 where we are making use of delegates to declare an Anonymous methods (highlighted in green). Wherever you thing creating a method is redundant or will create overhead you can go ahead and make use of Anonymous methods. Also one can use anonymous methods in cases where a method or property or constructor expects a delegate. In the above code we have declared a delegate with the signature of the method and then again using delegate variable, addResult, we are declaring an Anonymous method. One can write any number of statements inside Anonymous methods. The scope of the variables declared in Anonymous methods are within the limits of Anonymous methods.

Now lets see how we would have done this in the good olden days of C#1.0.

delegate int Add(int a, int b);
public void PrintAddResult(int num1, int num2)
{
//The good olden days of C#1.0
Add additionDel = Addition;
}

public int Addition(int a, int b)
{
return a + b;
}

In the above code you can see the good olden days of delegate declaration where one has to create a method (Addition) and then create a delegate (Add) representing the method. Once you have declared the delegate one can assign the method. So after seeing the olden ways of declaring the same functionality which can be achieved using Lambda expression one can see the advantages.

One can define two types of lambda, an Expression Lambda and a Statement Lambda. Lets see what each one of it means.

Expression Lambda: Expression lambda is nothing but an expression on the right side of the Lambda Operator. E.g are given below.

(a, b) => (a + b);
(int a, int b) => a > b;

An expressions is any piece of code which can be evaluated to a single value, object etc. So the above code are just e.g. of expressions, even an assignment of a value to a variable is also an expression.

Statement Lambdas: As the name suggests statement lambdas are ones which can have more than one line of code/statement. In expression lambda you normally have only one line of statement which executes and produces the output in the form of a single value or object etc whereas in statement lambda we have more than one line of statements enclosed in a curly brace ({}).

delegate int Add(int a, int b);
public void StatementLambda(int operand1, int operan2)
{
    Add result = (a, b) =>
    {
        int c = a + b;
        Console.WriteLine(c.ToString());
        return c;
    };
    result(operand1, operan2);
}

In the above code you can see we have written some three lines of code and this is an e.g. of statement Lambda. There are no restriction to the number of lines of code that can be written in a Lambda expression. As a good practice it will be nice if you can restrict the number of lines between 2 and 3 lines.

Some points about Lambda expressions

Lambda expressions are anonymous functions.
No need to declare the types of the variables used in the input parameter of the Lambda expression. The types will be inferred by the compiler.
If there are situation when the compiler cannot infer the type of the variable used, in those kind of scenarios we can explicitly declare the types for the input parameters as shown below.

delegate int Add(int a, int b);
public void PrintAddResult(int num1, int num2)
{
Add result = (int a, int b) => a + b;
Console.WriteLine(result(num1, num2).ToString());
}

Variables declared in a Lambda expressions are scoped inside the Lambda blocks.
Lambda declaration should match the signature of the delegate i.e. the number of parameters and return type.
Parameter less Lambdas can also be declared just by having a empty parentheses as shown below.

delegate void Print();
public void ParameterLessLambda()
{
Print print = () => Console.WriteLine("Parameter less lambda executed.");
print();
}

You can pass Lambda expression where a delegate is expected. E.g. is shown below.

/*Lambda expression passed as an argument where delegate was expected.*/
System.Threading.Thread thh = new System.Threading.Thread(
() => Console.WriteLine("hi"));

When you are making use of Lambda expressions behind the scene the compiler does the extra work of creating an anonymous function for the Lambda expression. Lets see with an e.g.: the code and generated IL are pasted below.

/*Class having a delegate and a Lambda expression.*/
class LambdaExpression
{
    delegate int Add(int operand1, int operand2);
    public void LambdaExp(int operan1, int operan2)
    {
        //Lambda expression.
        Add result = (a, b) => a + b;
        Console.WriteLine(result(operan1, operan2));
    }
}

/*Below is the MSIL generated for the above method. */
.method public hidebysig instance void LambdaExp(int32 operan1,
int32 operan2) cil managed
{
    .maxstack 3
    .locals init (
        [0] class
LambdaExpressions.LambdaExpression/Add result)
    L_0000: nop
    L_0001: ldsfld class
LambdaExpressions.LambdaExpression/Add
LambdaExpressions.LambdaExpression::CS$<>9__Cach
edAnonymousMethodDelegate1
    L_0006: brtrue.s L_001b
    L_0008: ldnull
    L_0009: ldftn int32
LambdaExpressions.LambdaExpression::<LambdaExp>b
__0(int32, int32)
    L_000f: newobj instance void
LambdaExpressions.LambdaExpression/Add::.ctor
(object, native int)
    L_0014: stsfld class LambdaExpressions.LambdaExpression/Add
LambdaExpressions.LambdaExpression::CS$<>9__Cach
edAnonymousMethodDelegate1
    L_0019: br.s L_001b
    L_001b: ldsfld class
LambdaExpressions.LambdaExpression/Add
LambdaExpressions.LambdaExpression::CS$<>9__Cach
edAnonymousMethodDelegate1
    L_0020: stloc.0
    L_0021: ldloc.0
    L_0022: ldarg.1
    L_0023: ldarg.2
    L_0024: callvirt instance int32
LambdaExpressions.LambdaExpression/Add::Invoke(i
nt32, int32)
    L_0029: call void [mscorlib]System.Console::WriteLine(int32)
    L_002e: nop
    L_002f: ret
}

/*C# code decompiled from MSIL using .NET Reflector*/
internal class LambdaExpression
{
    // Methods
    public void LambdaExp(int operan1, int operan2)
    {
        Add result = delegate (int a, int b) {
            return a + b;
        };
        Console.WriteLine(result(operan1, operan2));
    }

// Nested Types
private delegate int Add(int operand1, int operand2);
}

In the above pasted code you can see the MSIL generated is making use of AnonymousMethodDelegate i.e. the compiler is converting Lambda expressions into Anonymous functions. This is proven from the decompiled C# code from the MSIL pasted above.

As with other features of C# 3.0 Lambda expression is also a way of writing terse code where the compiler does the extra work of generating the extra codes. In my next we will have a look at Language Integrated Query (LINQ) for which all these features were incorporated in C#. Till then write terse code and try to learn more.

Sandeep

Working with Modal Popup extender control.

2009-07-03T14:26:00.001+05:30

This blog discusses about the ASP.NET AJAX ModalPopupExtender control. In this blog we will see how to use the ModalPopupExtender control, how to display/show/call the ASP.NET AJAX ModalPopupExtender control from javascript, showing/displaying/calling the modal popup from a hyper link control within the gridview control and finally some important javascript methods of the ASP.NET AJAX ModalPopupExtender control. So first lets see how to use the ModalPopupExtender control.

How to use the ASP.NET AJAX ModalPopupExtender control?

Drag and drop a ASP.NET button/LinkButton/ImageButton or any control to an aspx page. To add a ModalPopupExtender control, drag and drop the control from the toolbox or Select the control (button/LinkButton/ImageButton or any other control) and click the button with a greater than symbol as shown below.

When you click the arrow you will get a menu with an “Add Extender” option as shown below.

Click the “Add Extender” menu option and select “ModalPopupExtender” from “Extender Wizard” popup. Once you have added the ModalPopupExtender control you need an ASP.NET panel control. This is because the ModalPopupExtender control will show the content of the Panel control as a popup. Once you have added the ASP.NET Panel control add the content which you want to display as popup into the ASP.NET Panel control. Sample code with all the above requirement is pasted below. Don’t forget to drag and drop the ScriptManager control to the page.

<%@ Page Language="C#" AutoEventWireup="true" CodeFile="ModalPopup.aspx.cs" Inherits="ModalPopup" %>
<%@ Register Assembly="AjaxControlToolkit" Namespace="AjaxControlToolkit" TagPrefix="cc1" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
    <title>Modal Popup Demo</title>
    <style>
    .backgroundColor
    {
        background-color:Gray;
        filter:alpha(opacity=25);
    }
    </style>
</head>
<body>
    <form id="form1" runat="server">
    <div>
        <asp:ScriptManager ID="ScriptManager1" runat="server">
        </asp:ScriptManager>
        <asp:Button ID="popupBtn" runat="server" Text="Click to see the modal popup." />
        <asp:Panel ID="Panel1" runat="server" Style="display: none; padding:10px; border:1px; border-style:solid;" BackColor="#FF9933" Width="400px">
            <h3 style="text-align: center;" id="header">Modal Popup</h3>
            <p>This is a Modal Popup extender control. You are seeing this because you have clicked the hyperlink button.</p>
            <p style="text-align: center;"><asp:Button ID="closeBtn" runat="server" Text="Close" /></p>
        </asp:Panel>
        <cc1:ModalPopupExtender ID="ModalPopupExtender" runat="server"
            TargetControlID="popupBtn"
            PopupControlID="Panel1"
            OkControlID="closeBtn"
            BackgroundCssClass="backgroundColor"
            DropShadow="true"
            PopupDragHandleControlID="header"/>
    </div>
    </form>
</body>
</html>

From the above code one can see I have a ScriptManager, an asp:Button control, an asp:Panel control, some contents inside the panel control and then we have the ModalPopupExtender control. Normally when you attach an ASP.NET panel control it will become invisible and if due to some reason if the panel control is being displayed in the page then just set the “display” to “none” as highlighted in Maroon in the above e.g. So when you click the button you will see a popup as shown below.

Now lets see how to configure the ModalPopupExtender control. The configuration is pretty simple, you need to set some properties and and you will have your Modal popup. The properties are as follows

TargetControlID: This property is the one which tells, on click of which control the popup should be displayed. In our e.g. we have given the TargetControlID as our button control. You can assign the ID of any ASP.NET controls like LinkButton, ImageButton, HyperLink, DropDownList, CheckBox, RadioButton etc. Even you can give a label’ id as the TargetControlID.

PopupControlID: The ID of the control to be displayed as a modal popup. In our e.g. we have given ASP.NET panel control’ ID. You can give any ASP.NET control’ ID. If for e.g if you give the ID of a textbox then the textbox alone will be popped up. Its not compulsory that you should provide a ASP.NET panel control.

OkControlID: The ID of the control which should act as an Ok button. Clicking of this control will dismiss the popup.

BackgroundCssClass: The name of the CSS class which needs to be applied to the background of the popup. One thing to note here is that if you don’t provide a CSS class then the modal popup will not function like a modal dialog. One will be able to interact with the controls at the background of the popup control, so its imperative to provide a valid CSS class name value to the BackgroundCssClass property. In the above e.g. we have defined a CSS class called “backgroundColor” in the header section of the aspx page. Please note in the CSS class definition we have applied “filter” property to make the background transparent.

DropShadow: Accepts a boolean value which specifies whether the popup should have shadow. True will give a shadow and false will disable the shadow.

PopupDragHandleControlID: The ID of the control clicking on which the ModalPopupExtender can be dragged. The control should be inside the control specified using PopupControlID i.e. in our case control inside the ASP.NET panel control. If a particular control ID is set as the PopupDragHandlerControlID then one can click on that control and drag the ModalPopupExtender control. In the above e.g. we have set the ID of the “h3” control as PopupDragHandleControlID, clicking which the popup can be dragged.

CancelControlID: If you want a button to behave as a Cancel button provide the ID of the button. This button will cancel the popup.

Drag: This property takes a boolean value which when set decides whether the popup control can have the drag feature. A value of true means the popup extender control can be dragged around the screen whereas false will disable the drag.

RepositionMode: This property accepts four values. They are “None”, “RepositionOnWindowResize”, “RepositionOnWindowResizeAndScroll” and “RepositionOnWindowScroll”. The default value is “RepositionOnWindowResizeAndScroll”. Explanation of each values is given below.

RepositionOnWindowResize: Will reposition the popup when the window is resized.

RepositionOnWindowScroll: Will reposition the popup when the scroll bar is moved.

RepositionOnWindowResizeAndScroll: Will reposition the popup when you resize or when you move the scroll bar. Its a combination of both “RepositionOnWindowResize” and “RepositionOnWindowScroll”.

None: The popup will not be tinkered with. It will be shown in its original position irrespective of window resizing or scroll bar being moved.

DynamicServicePath: Link to a webservice/aspx page from where data or content needs to be retrieved and displayed in the popup extender control.

DynamicServiceMethod: The method name from which content needs to be retrieved. The method can be a webservice method or a method in your code behind file of your aspx file. If you leave the “DynamicServicePath” empty and provide DynamicServiceMethod name then the system will try to ping the same page’ and try to find a method. We will see an e.g. with web service shortly.

DynamicContextKey: The string value which will be passed as the parameter to the method specified in DynamicServiceMethod. One thing to note here is that the parameter should be named contextKey in the webservice/code behind.

X: The X coordinates for the popup control.

Y: The Y coordinates for the popup control.

Showing the content of a webservice (asmx) method in a ModalPopupExtender control.

Showing the output of a web method of a web service in a ModalPopupExtender control is also pretty simple. First you need to have a web service, if you don’t have one its very easy to create one in Visual Studio. Create a web service and add a method the output of which you want to display in a ModalPopupExtender conrol. Below I have pasted the code of my webservice.

using System;
using System.Collections;
using System.Linq;
using System.Web;
using System.Web.Services;
using System.Web.Services.Protocols;
using System.Xml.Linq;

[WebService(Namespace = "http://tempuri.org/")]
/*The below attribute is needed so that the webservice can process calls from ASP.NET AJAX controls. Without the below attribute one may get the following error. "Web Service call failed: 500"*/
[System.Web.Script.Services.ScriptService]
public class Service : System.Web.Services.WebService
{
    public Service ()
    {
    }
    /*Method which will be called by the ModalPopupExtender control.*/
    [WebMethod]
    public string HelloWorld()
    {
        return "<b>Hello World</b><br/>";
    }
}

The above webservice is pretty simple. It has only one web method and the most famous of them all, the “HelloWorld” method. The method returns a HTML formatted “Hello World” string.

One thing to note while writing a web service whose methods can be called by the ASP.NET Ajax controls is that you need to add the “[System.Web.Script.Services.ScriptService]” attribute. If the before mentioned attribute is not added then you may get the below web service error.

“Web Service call failed: 500”

The mark up for the ModalPopupExtender control to display the webservice’ web method output is pasted below.

<asp:Panel ID="webServicePanel" runat="server" Width="300px" Height="300" BackColor="Azure">
    <asp:Label ID="webServiceContentLbl" runat="server" Text="Label"></asp:Label>
    <asp:Button ID="clsBtn" runat="server" Text="Button" />
</asp:Panel>
<asp:Button ID="webServiceCall" runat="server" Text="Click to see the output of a webservice in a popup." />
<cc1:ModalPopupExtender ID="ModalPopupExtender1" runat="server" TargetControlID="webServiceCall" OkControlID="clsBtn" DynamicServicePath="Service.asmx" DynamicServiceMethod="HelloWorld"   DynamicControlID="webServiceContentLbl"
BackgroundCssClass="backgroundColor" PopupControlID="webServicePanel" DropShadow="true">
</cc1:ModalPopupExtender>

The difference from our previous ModalPopupExtender control is that we have configured some extra properties related to webservice request. They are DynamicServicePath where we have given the url of the web service, DynamicServiceMethod takes the web method name and finally DynamicControlID takes the ID of the control in which the output of the web method should be displayed. We have given the ID of the label control inside the panel control as the DynamicControlID. The label control will display “Hello World” string in bold.

The ModalPopupExtender is capable of displaying the output from normal aspx pages as well. To display some content its not compulsory that you need to create a webservice. One can directly show the output of a method in a code behind file in a ModalPopupExtender. Lets see how to do that.

Displaying the content of a webpage (aspx) method in a ModalPopupExtender control.

Below is the code behind file content of the ASPX page. The code is pretty straight forward. It has a static method called HelloWorld which returns the same text as that of the webservice.

public partial class ModalPopup : System.Web.UI.Page
{
    protected void Page_Load(object sender, EventArgs e)
    {
    }
    /// <summary>
    /// Page method which will be called by the modal popup extender control.
    /// </summary>
    /// <returns></returns>
    [System.Web.Services.WebMethod(), System.Web.Script.Services.ScriptMethodAttribute()]
    public static string HelloWorld()
    {
        return "<b>Hello World</b><br/>";
    }
}

One thing to keep in mind when you declare a method in an aspx which needs to be accessed by the ModalPopupExtender control or any ASP.NET AJAX control is to apply the following attribute.

[System.Web.Services.WebMethod(), System.Web.Script.Services.ScriptMethodAttribute()]

In addition to the above method attributes one need to declare the method as a static method. If the method is not declared static then you may not be able to ping from the client side. In the case of web service the method need not be static. Some of the errors which you may face because of not declaring the method static or because of not applying the above attributes are listed below.

1. Web Service call failed: 12030
2. Web Service call failed: 500

If the above two errors popup you know what to do? First check whether the method attributes are applied and secondly see to it that the method is declared as static in the code behind.

Below is the mark up needed to display the content from a method in an aspx page.

<asp:Panel ID="webServicePanel" runat="server" Width="300px" Height="300" BackColor="Azure">
    <asp:Label ID="outputContentLbl" runat="server" Text="Label"></asp:Label>
    <asp:Button ID="clsBtn" runat="server" Text="Button" />
</asp:Panel>
<asp:Button ID="webServiceCall" runat="server" Text="Click to see the output of a webservice in a popup." />
<cc1:ModalPopupExtender ID="ModalPopupExtender1"       runat="server" DynamicServicePath="ModalPopup.aspx"
    TargetControlID="webServiceCall"          OkControlID="clsBtn"          DynamicServiceMethod="HelloWorld"          DynamicControlID="outputContentLbl"          BackgroundCssClass="backgroundColor"          PopupControlID="webServicePanel" DropShadow="true">
</cc1:ModalPopupExtender>

You can see in the above mark up everything is same except for the webservice related properties, highlighted in Maroon. DynamicServicePath is used to specify the url of the page. If left blank it will refer the same page. DynamicServiceMethod is the method name in the aspx/codebehind which will be pinged by the ModalPopupExtender to retrieve data. DynamicControlID is the ID of the control in which you would like to display the output of the method. DynamicControlID should have the ID of a control inside the ASP.NET Panel control in our case or any control inside whatever container control the user is making use for popup. Also if you have any argument then you can use DynamicContextKey to pass the string argument.

Hiding and Showing the ModalPopupExtender control using javascript

The above e.g. are quite straight forward and easy to implement. Unfortunately a developer’ life is not a bed of roses. There may arise a requirement where one has to call/show/hide the popup control using javascript. So lets see how to do exactly this. Below is the HTML markup.

<asp:Button ID="popupScriptBtn" runat="server" Text="Click to view the modal popup using javascript"   OnClientClick=”javascript:showModalPopup();return false;” />
<asp:Button ID="popupBtn" runat="server" Text="Click to see the modal popup." />
<div ID="div1" runat="server" >
    <asp:Panel ID="Panel1" runat="server" Style="display: none; padding:10px; border:1px; border-style:solid;" BackColor="#FF9933" Width="400px">
        <table id="Table1" style="background-color: #C0C0C0; width: 400px; height: 5px;"><tr><td><h3 style="text-align: center;" id="header">Modal Popup</h3></td></tr></table>
        <p>This is a Modal Popup extender control. You are seeing this because you have clicked the hyperlink button.</p>
        <p style="text-align: center;"><asp:Button ID="closeBtn" runat="server" Text="Close" /></p>
    </asp:Panel>
</div>
<cc1:ModalPopupExtender ID="ModalPopupExtender" runat="server" TargetControlID="popupBtn"
    PopupControlID="Panel1" OkControlID="closeBtn"
    BackgroundCssClass="backgroundColor"
    DropShadow="true" PopupDragHandleControlID="header"
    CancelControlID="" Drag="true" RepositionMode="None" />

Above markup is pretty much same as the one we used at the beginning of the blog. The only difference being we have an extra ASP.NET button, clicking which we will show the ModalPopupExtender control with the help of javascript. In the above markup we have used the “OnClientClick” property to assign the javascript, showModalPopup, which needs to be called when the button is clicked. The javascript to show and hide the popup is pasted below.

In the above javascript we have two functions. One to show the ModalPopupExtender control and another to hide the control. In both the function we are using $find shortcut method to retrieve the popup control. To know more about $find method please see this link. Once we have retrieved the modal popup control we are calling the show and hide methods of the control to show and hide the control respectively.

Using the modal popup control within a GridView control

There is nothing different here. In a grid if you want to link the ModalPopupExtender to a control inside the GridView you need to just convert the column into a template column and add the ModalPopupExtender control to the column and configure the necessary properties as discussed. Below is a sample code where I have added the ModalPopupExtender control in the header section as well in a column of GridView control.

<asp:GridView ID="backIssueGrid" runat="server" AutoGenerateColumns="False"
            DataMember="issue" DataSourceID="backIssuesXML">
        <RowStyle BorderColor="Tan" BorderStyle="Solid" BorderWidth="1px" />
        <Columns>
            <asp:TemplateField HeaderText="Back Issues" HeaderStyle-CssClass="headerText">
                <ItemTemplate>
                    <asp:HyperLink ID="title" runat="server"
                        Text='<%# XPath("@title") %>' CssClass="gridText" NavigateUrl='<%# XPath("url") %>'></asp:HyperLink>
                    <asp:Panel ID="webServicePanel" runat="server" Width="300px" Height="300" BackColor="Azure">
                        <asp:Label ID="outputContentLbl" runat="server" Text="Label"></asp:Label>
                        <asp:Button ID="clsBtn" runat="server" Text="Button" />
                    </asp:Panel>
                    <cc1:ModalPopupExtender ID="ModalPopupExtender1" runat="server" DynamicServicePath="ModalPopup.aspx"
                        TargetControlID="title" OkControlID="clsBtn"
                        DynamicServiceMethod="HelloWorld"
                        DynamicControlID="outputContentLbl"
                        BackgroundCssClass="backgroundColor" PopupControlID="webServicePanel"
                        DropShadow="true">
                    </cc1:ModalPopupExtender>
                </ItemTemplate>
                <HeaderStyle CssClass="headerText"></HeaderStyle>
                <ItemStyle BorderColor="Tan" BorderStyle="Solid" BorderWidth="1px" />
            </asp:TemplateField>
            <asp:TemplateField HeaderStyle-CssClass="headerText">
                <ItemTemplate>
                    <asp:TextBox ID="quantityTxt" Width="30" runat="server" Text='<%#XPath("@noOfCopies") %>' CssClass="gridText"></asp:TextBox>
                </ItemTemplate>
                <ItemStyle BorderColor="Tan" HorizontalAlign="Center" BorderStyle="Solid" BorderWidth="1px" />
                <HeaderStyle CssClass="headerText"></HeaderStyle>
                <HeaderTemplate>
                    <asp:ImageButton ID="ImageButton1" runat="server" ImageUrl="some.gif" />
                    <asp:Panel ID="webServicePanel2" runat="server" Width="300px" Height="300" BackColor="Azure">
                        <asp:Label ID="outputContentLbl1" runat="server" Text="Label"></asp:Label>
                        <asp:Button ID="clsBtn" runat="server" Text="Button" />
                    </asp:Panel>
                    <cc1:ModalPopupExtender ID="ModalPopupExtender2" runat="server" DynamicServicePath="ModalPopup.aspx"
                        TargetControlID="ImageButton1" OkControlID="clsBtn"
                        DynamicServiceMethod="HelloWorld"
                        DynamicControlID="outputContentLbl1"
                        BackgroundCssClass="backgroundColor" PopupControlID="webServicePanel2"
                        DropShadow="true">
                    </cc1:ModalPopupExtender>
                </HeaderTemplate>
            </asp:TemplateField>
            <asp:TemplateField>
                <ItemTemplate>
                    <asp:Label ID="Label4" CssClass="gridText" runat="server" Text='<%# Add(XPath("@noOfCopies"), XPath("@price"))%>'></asp:Label>
                </ItemTemplate>
            </asp:TemplateField>
            <asp:CommandField ShowSelectButton="True" ButtonType="Button"
                SelectText="Remove" ControlStyle-CssClass="buttonText" >
            <ControlStyle CssClass="buttonText"></ControlStyle>
            <ItemStyle BorderColor="Tan" BorderStyle="Solid" BorderWidth="1px" />
            </asp:CommandField>
        </Columns>
        <EditRowStyle BorderStyle="Solid" />
    </asp:GridView>

In the above e.g. you can see the markups highlighted in green. In the first portion I have place a popup control in the “ItemTemplate” and hooked the ModalPopupExtender control to a hyperlink control. Pretty simple, isn’t it? In the second section I have put the popup control in the HeaderTemplate of the column and hooked it to a ImageButton. So when one clicks on the image button in the header he will see a popup. If you want you can add javascript “onmouseover” and “onmouseout” behavior to the image in the code behind by adding attributes to the ImageButton control.

In my case I had to show help text whenever the user clicks the header text so instead of adding ModalPopupExtender control to each and every HeaderTemplate what I did is added the ModalPopupExtender control somewhere in the aspx page and hooked it to a hidden control and on click of the header, used javascript to display the popup control. The reason why I took this approach is that if I put the ModalPoupExtender in each column’ header template, it will generate as many popup extenders as the number of columns. My popup control needs to display help text and these help text were retrieved from a method in the code behind/webservice. So I used a javascript function and passed parameters necessary to retrieve the help text. Also people who have similar kind of requirement where for e.g. you have a column and you need to show some help text or some detailed information based on some parameters you can also follow the same approach. The approach will reduce the amount of html being generated. With this approach I wanted to highlight the subtle feature of ModalPopupExtender control where one can hook up the control to a hidden control and use javascript to show the control. This method can be very useful for controls to which ModalPopupExtender cannot be attached. I think thats enough, lets see the code in action.

<asp:GridView ID="backIssueGrid" runat="server"
AutoGenerateColumns="False" DataMember="issue"
DataSourceID="backIssuesXML">
        <RowStyle BorderColor="Tan"
BorderStyle="Solid" BorderWidth="1px" />
        <Columns>
            <asp:TemplateField
HeaderStyle-CssClass="headerText">
                <HeaderTemplate>
                    <asp:HyperLink ID="title"
runat="server" Text="Name" CssClass="gridText"
NavigateUrl='javascript:showModalPopup("helpOne"
);'></asp:HyperLink>
                </HeaderTemplate>
                <ItemTemplate>
                    <asp:HyperLink ID="title"
runat="server" Text='<%# XPath("@title") %>'
CssClass="gridText" NavigateUrl='<%#
XPath("url") %>'></asp:HyperLink>                        </ItemTemplate>
                <HeaderStyle
CssClass="headerText"></HeaderStyle>
                <ItemStyle BorderColor="Tan"
BorderStyle="Solid" BorderWidth="1px" />                        </asp:TemplateField>
            <asp:TemplateField
HeaderStyle-CssClass="headerText">                       <ItemTemplate>
                    <asp:TextBox
ID="quantityTxt" Width="30" runat="server"
Text='<%#XPath("@noOfCopies") %>'
CssClass="gridText"></asp:TextBox>
                </ItemTemplate>
                <ItemStyle BorderColor="Tan"
HorizontalAlign="Center" BorderStyle="Solid"
BorderWidth="1px" />
               <HeaderStyle
CssClass="headerText"></HeaderStyle>
                <HeaderTemplate>
                    <asp:HyperLink ID="title"
runat="server" Text="Address" CssClass="gridText"                         NavigateUrl='javascript:showModalPopup("helpTwo"
);'></asp:HyperLink>                                             </HeaderTemplate>
            </asp:TemplateField>
            <asp:CommandField
ShowSelectButton="True" ButtonType="Button"
SelectText="Remove" ControlStyle-CssClass="buttonText" >
            <ControlStyle
CssClass="buttonText"></ControlStyle>
            <ItemStyle BorderColor="Tan"
BorderStyle="Solid" BorderWidth="1px" />
            </asp:CommandField>
        </Columns>
</asp:GridView>
<asp:XmlDataSource ID="backIssuesXML"
runat="server"
DataFile="~/Data/BackIssue.xml"></asp:XmlDataSou
rce>
<asp:HyperLink ID="title" runat="server"
Style="display:none;"> </asp:HyperLink>
        <asp:Panel ID="webServicePanel"
runat="server" Width="300px" Height="300"
BackColor="Azure">
            <asp:Label ID="outputContentLbl"
runat="server" Text="Label"></asp:Label>
            <asp:Button ID="clsBtn"
runat="server" Text="Button" />
        </asp:Panel>
<cc1:ModalPopupExtender ID="ModalPopupExtender1"
runat="server" DynamicServicePath="ModalPopup.aspx"
TargetControlID="title" OkControlID="clsBtn"
DynamicServiceMethod="HelloWorld"
DynamicControlID="outputContentLbl"
BackgroundCssClass="backgroundColor" PopupControlID="webServicePanel" DropShadow="true">
</cc1:ModalPopupExtender>

The above code has ASP.NET hyper link controls in the header template which calls a javascript function using its NavigateUrl property and passes a string value to the javascript function based on which the help text is retrieved. Also as you can see we have a ModalPopupExtender control outside of GridView. A javascript function is used to show the popup control when you click the hyper link controls inside the header template of the gridview. Also note the hyper link control outside the GridView which has its style set to “None” so that the control becomes invisible. The javascript which is executed on clicking the hyper link controls inside the GridView is pasted below.

//Javascript function to show the ModalPopupExtender control.
function showModalPopup(helpId)
{
    var modalPopup = $find('<%=ModalPopupExtender1.ClientID %>');
    if (modalPopup != null)
    {
        modalPopup._DynamicContextKey = helpId;
        modalPopup.show();
    }
}

In the above javascript we are setting the “_DynamicContextKey” with the help of the method argument. The argument is passed by the hyper link controls in the header template of the GridView. DynamicContextKey are nothing but the string arguments to be passed to webservice/webpage method. So by varying the DynamicContextKey we can get different messages to be displayed in the ModalPopupExtender control.

The code behind method which is called by the ModalPopupExtender control is pasted below.

[System.Web.Services.WebMethod(), System.Web.Script.Services.ScriptMethodAttribute()]
    public static string HelloWorld(string contextKey)
    {
        return "<b>Hello World</b><br/>" + contextKey;
    }

So that’ about working with ModalPopupExtender control. Below are some of the important javascript properties and methods of ModalPopupExtender control.

Method/Properties	Description
_DynamicControlID	Using this property you can set/retrieve the ID for the dynamic control i.e. the control which will show the output of the method being pinged by the modal popup extender control.
_DynamicContextKey	Property to set/retrieve the string parameter for the function which will be called by the ModalPopupExtender control.
_DynamicServicePath	Property to set/retrieve the path for the webservice/webpage.
_DynamicServiceMethod	Property to set/retrieve the method which needs to be invoked or pinged to retrieve the output.
_PopupControlID	The property can be used to set/retrieve the ID of the control which will be shown as the popup. Normally it will be the ID of the ASP.NET panel control.
_PopupDragHandleControlID	The ID of the control clicking on which the popup control can be dragged.
_BackgroundCssClass	CSS class name for the background of the popup can be set/retrieved using this javascript property.
_DropShadow	Boolean value which can be set/retrieved to enable drop shadow. A value of “true” means drop shadow is enabled, false means it is disabled.
_Drag	Property to set/retrieve the drag facility. If you want to enable set it as true.
_OkControlID	This property can be used to set/retrieve the “Ok” button.
_CancelControlID	Property to set/retrieve the “Cancel” button id.
_OnOkScript	Property to set/retrieve the script which needs to fired when “Ok” button inside the popup is clicked.
_OnCancelScript	Property to set/retrieve the script which needs to fired when “Cancel” button inside the popup is clicked.
_xCoordinate	Property to set/retrieve the X coordinates of the popup control.
_yCoordinate	Property to set/retrieve the Y coordinates of the popup control.
_repositionMode	Property to set/retrieve the Reposition mode. Reposition mode has been discussed somewhere else in this document. The property accepts integer as its value. The various values and their corresponding reposition mode are as follows. 0 means “None”, 1 means “RepositionOnWindowResize”, 2 means “RepositionOnWindowScroll” and finally 3 means “RepositionOnWindowResizeAndScroll”. Each of this mode is discussed above.
_id	One can set/retrieve the ID of the ModalPopupExtender control.

So that’ about our disussion on ModalPopupExtender control.

Try to know more,

Sandeep

Serialization in .NET - 3

2009-07-01T14:46:00.001+05:30

In my previous two article we discussed Binary Serialization and XML Serialization. This blog we will try to know more about SOAP (Simple Object Access Protocol) serialization. First up lets see how to serialize an object to SOAP format. We will take our good old Car class which most of you are very familiar with. The Car class is pasted below.

public class Car
{
    public string Color
    { get; set; }
    public string Model
    { get; set; }
    public int NoOfDoors
    { get; set; }
    public int Price
    { get; set; }
    public string CubicCentimeter
    { get; set; }
    public CarType Type
    { get; set; }
}

We will make use of the above car class for SOAP serialization. The code to serialize a class to SOAP format is similar to XML serialization with a small difference. The code is pasted below.

Car bmw3Series = new Car{Model = "BMW 3 Series", Color = "Blue", NoOfDoors = 4, CubicCentimeter="3500cc"};
using (System.IO.Stream soapStream = new System.IO.FileStream("SoapFormat.xml", System.IO.FileMode.OpenOrCreate))
{
    System.Xml.Serialization.SoapReflectionImporter soapRefImp = new System.Xml.Serialization.SoapReflectionImporter();
    System.Xml.Serialization.XmlTypeMapping xmlTypeMapping =
        soapRefImp.ImportTypeMapping(typeof(Car));
    System.Xml.Serialization.XmlSerializer xmlSerializer =
        new System.Xml.Serialization.XmlSerializer(xmlTypeMapping);
    xmlSerializer.Serialize(soapStream, bmw3Series);
}

To serialize an object to SOAP format one can make use of XmlSerilizer class. When we initialize the XmlSerializer class for SOAP serialization instead of passing the type of the object we pass an instance of XmlTypeMapping class. This is the subtle difference. As you can see from the above code we are instantiating XmlTypeMapping object by passing the type of the Car object to the ImportTypeMapping method of SoapReflectionImporter class. SoapReflectionImporter class can be used whenever you want to serialize objects to SOAP formats.

The SOAP XML generated from the above code for the Car class is pasted below.

<?xml version="1.0" ?>
<Car xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" id="id1">
<Color xsi:type="xsd:string">Blue</Color>
<Model xsi:type="xsd:string">BMW 3 Series</Model>
<NoOfDoors xsi:type="xsd:int">4</NoOfDoors>
<Price xsi:type="xsd:int">0</Price>
<CubicCentimeter xsi:type="xsd:string">3500cc</CubicCentimeter>
</Car>

Another way to serialize objects is by making use of SoapFormatter class. To make use of the SoapFormatter class one has to add a reference to the “System.Runtime.Serialization.Formatters.Soap.dll” assembly. The sample code is pasted below.

using (System.IO.Stream soapStream = new System.IO.FileStream("SoapFormatter.xml", System.IO.FileMode.Create))
{
    System.Runtime.Serialization.Formatters.Soap.SoapFormatter soapFormatter =
        new System.Runtime.Serialization.Formatters.Soap.SoapFormatter();
    soapFormatter.Serialize(soapStream, bmw3Series);
}

The SOAP xml generated from the above code is pasted below.

<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-
instance" xmlns:xsd="http://www.w3.org/2001/
XMLSchema" Xmlns:SOAP-ENC="http://schemas.
xmlsoap.org/soap/encoding/" xmlns:SOAP-ENV=
"http://schemas.xmlsoap.org/soap/envelope/" xmlns:clr="http://schemas.microsoft.com/soap
/encoding/clr/1.0" SOAP-ENV:encodingStyle=
"http://schemas.xmlsoap.org/soap/encoding/">
<SOAP-ENV:Body>
<a1:Car id="ref-1" xmlns:a1="http://schemas.microsoft.com/clr/
nsassem/SoapSerialization/SerializationSample%
2C%20Version%3D1.0.0.0%2C%20Culture%3Dneutral%
2C%20PublicKeyToken%3Dnull">
<_x003C_Color_x003E_k__BackingField id="ref-3">Blue</_x003C_Color_x003E_k__
BackingField>
<_x003C_Model_x003E_k__BackingField id="ref-4">BMW 3 Series</_x003C_Model_x003E_k__BackingField>
<_x003C_NoOfDoors_x003E_k__BackingField>4
</_x003C_NoOfDoors_x003E_k__BackingField>
<_x003C_Price_x003E_k__BackingField>0
</_x003C_Price_x003E_k__BackingField>
<_x003C_CubicCentimeter_x003E_k__BackingField id="ref-5">3500cc</_x003C_CubicCentimeter_
x003E_k__BackingField>
</a1:Car>
</SOAP-ENV:Body>
</SOAP-ENV:Envelope>

I would not recommend using SoapFormatter class as this class is obsolete from .NET 3.5 version. Also SoapFormatter class doesn’t support serialization of generic collections.

That's pretty much how objects can be serialized to SOAP format. As in the case with XML serialization there may be situation where you would like to control the way objects are serialized to SOAP format. This can be very much useful when you are using webservices where you would like to take control of the way your objects are serialized. Following are some of the attributes which can be applied to control object serialization.

SoapAttribute

One can apply “SoapAttribute” to convert the property or field as a XML attribute rather than as a XML node which is the normal behavior. If you want to change the attribute name and don’t want it to be same as that of the property name, you can make use of the “AttributeName” property along with “SoapAttribute”. To provide a namespace to the xml attribute you can make use of the “Namespace” property. When you provide namespace it has to abide by w3 guidelines. As a general practice we provide urls as namespace. If you want to provide the data type to the attribute again that can be specified with the help DataType property. Sample code is pasted below.

public class Car
{
   [System.Xml.Serialization.SoapAttribute (AttributeName="CarColor", DataType="string", Namespace="http://car")]
    public string Color
    { get; set; }
    public string Model
    { get; set; }
    public int NoOfDoors
    { get; set; }
    public int Price
    { get; set; }
    public string CubicCentimeter
    { get; set; }
}

The serialized XML after applying the “SoapAttribute” is pasted below.

<?xml version="1.0"?>
<Car xmlns:xsi="http://www.w3.org/2001/XMLSchema-inst
ance"xmlns:xsd="http://www.w3.org/2001/XMLSchema" id="id1"d1p1:CarColor="Blue" xmlns:d1p1="http://car">
<Model xsi:type="xsd:string">BMW 3 Series</Model>
<NoOfDoors xsi:type="xsd:int">4</NoOfDoors>
<Price xsi:type="xsd:int">0</Price>
<CubicCentimeter xsi:type="xsd:string">
3500cc</CubicCentimeter>
</Car>

From the above pasted XML you can see how the Color property has been added as a SOAP attribute to the Car node.

SoapElement

SoapElement can be used to control the xml element’ attributes. Using the SoapElement attribute on a public property/field will convert the property/field to a XML element. The properties which can be used with SoapElement are, ElementName, DataType, and IsNullable.

With ElementName one can provide a Name to the element if you don’t want the SOAP XML element name to be same as that of the property/field name.

DataType will help you to specify the SOAP XML schema data type.

IsNullable specifies whether a SOAP XML element node should be generated if the property/field is null. If the IsNullable value is true an empty XML element with xsi:nil attribute set to true will be generated for properties/fields having null value else no XML element node will be generated. As we have learned in XML serialization, if IsNullable is used in SOAP serialization it won’t throw any error even if it is used along with value type objects. In SOAP serialization if you have set IsNullable to true then for value type it will create a node with a default value assigned to it. For e.g. if you have used IsNullable for int data type and boolean data type then the SOAP xml will have nodes with 0 and false as their default value, if they are not initialized. Sample code with these implementation and the SOAP XML is pasted below.

public class Car
{
    [System.Xml.Serialization.SoapElement
(ElementName = "CarColor", IsNullable = true)]
        public string Color
        { get; set; }
        [System.Xml.Serialization.SoapElement (ElementName="CarModel")]
        public string Model
        { get; set; }
        public int NoOfDoors
        { get; set; }
        [System.Xml.Serialization.SoapElement (ElementName = "CarPrice", IsNullable = true)]
        public int Price
        { get; set; }
        public string CubicCentimeter
        { get; set; }
}

//Car object to be serialized.
Car bmw3Series = new Car{Model = "BMW 3 Series", NoOfDoors = 4, CubicCentimeter="3500cc"};

//Serialized SOAP XML
<?xml version="1.0"?>
<Car xmlns:xsi="http://www.w3.org/2001/XMLSchema
- instance" xmlns:xsd="http://www.w3.org/2001/
XMLSchema" id="id1">
<CarColor xsi:nil="true" />
<CarModel xsi:type="xsd:string">BMW 3 Series</CarModel>
<NoOfDoors xsi:type="xsd:int">4</NoOfDoors>
<CarPrice xsi:type="xsd:int">0</CarPrice>
<CubicCentimeter xsi:type="xsd:string">3500cc</CubicCentimeter>
</Car>

From the above xml one can see there is “xsi:nill” XML attribute set to true for “CarColor” node as we have applied “IsNullable” true. Also notice “CarPrice” node having “0” as its value. Since we have used “IsNullable” it is generating a node with a default value.

SoapEnum

Can be used to describe how Enum needs to be serialized. It has only one property named Name using which you can specify what should be the name of the particular Enum value. Sample code is pasted below.

public enum CarType
{
    [System.Xml.Serialization.SoapEnum(Name = "CompactCar")]
    SmallCar,
   [System.Xml.Serialization.SoapEnum(Name= "CompactSedan")]
    CS,
    Sedan,
    SportsCar,
    Suv
}

If the “Name” property is specified then the enum’ member will have the name specified in the “Name” property else it will default to the member name.

SoapIgnore

If you want a public field or property not to be serialized then you can make use SoapIgnore attribute. This will prevent a particular public field or property from being serialized. SoapIgnore doesn’t have any property. The serialized XML and SoapIgnore attribute applied to Color property of the Car class is pasted below.

public class Car
{
    [System.Xml.Serialization.SoapIgnore]
    public string Color
    { get; set; }
    [System.Xml.Serialization.SoapElement (ElementName="CarModel")]
    public string Model
    { get; set; }
    public int NoOfDoors
    { get; set; }
    [System.Xml.Serialization.SoapElement(ElementName = "CarPrice", IsNullable = true)]
    public int Price
    { get; set; }
    public string CubicCentimeter
    { get; set; }
}

//Car object which needs to be serialized
Car bmw3Series = new Car{Model = "BMW 3 Series",
NoOfDoors = 4, Color="Blue", CubicCentimeter="3500cc"};

//Serialized XML with SoapIgnore attribute applied.
<?xml version="1.0"?>
<Car xmlns:xsi="http://www.w3.org/2001/
XMLSchema-instance" xmlns:xsd="http://www.w3.org
/2001/XMLSchema" id="id1">
<CarModel xsi:type="xsd:string">BMW 3 Series</CarModel>
<NoOfDoors xsi:type="xsd:int">4</NoOfDoors>
<CarPrice xsi:type="xsd:int">0</CarPrice>
<CubicCentimeter xsi:type="xsd:string">3500cc</CubicCentimeter>
</Car>500cc</CubicCentimeter>
</Car>

From the above pasted SOAP XML one can note that Color attribute is missing because of the usage of SoapIgnore.

SoapInclude

SoapInclude can be used to specify the derived classes to be included in the SOAP format. For e.g. you have Car class and other classes like “CompactCar”, “Sedan” etc are deriving from Car class then you can make use SoapInclude. Suppose you have a class called CarCollection where you have a property called CarInstance which is a generic collection of base type Car. When the CarCollection object is serialized one has to tell the compiler what classes the collection can hold or derives from. If one is not specifying the inherited classes using the SoapInclude attribute the serialization process throws the following error.

InvalidOperationException outer exception: "There was an error generating the XML document."
InvalidOperationException inner exception: "The type SoapSerialization.CompactCar was not expected. Use the XmlInclude or SoapInclude attribute to specify types that are not known statically."

To avoid the above error you can use SoapInclude attribute. A sample code is pasted below.

//Derived classes.
public class CompactCar : Car
{
public string SomeProperty
{ get; set; }
}

public class Sedan : Car
{
    public int SedanCapacity
        { get; set; }
}
\*Class has a generic collection of type car. One has to use SoapInclude to tell the serializer that the class can have classes of type CompactCar and Sedan.*/
[System.Xml.Serialization.SoapInclude(typeof(CompactCar)),
        System.Xml.Serialization.SoapInclude(typeof(Sedan))]
public class CarCollection
{
        public System.Collections.Generic.List<Car> CarInstance
        { get; set; }
}

Sometimes using the SoapInclude attribute may not solve the problem rather it can throw a new error. The error with inner exception is pasted below.

System.InvalidOperationException: "There was an error generating the XML document."
System.InvalidOperationException: "Token StartElement in state Epilog would result in an invalid XML document."

To solve this you need to add a start element and end element before and after the serialized SOAP xml using XmlTextWriter’ WriteStartElement and WriteEndElement methods respectively. The logic behind this is to add a root node. The SOAP serialization code is modified and pasted below.

using (System.IO.Stream soapStream = new System.IO.FileStream("SoapFormat.xml",
    System.IO.FileMode.Create))
{
    using (System.Xml.XmlTextWriter xmlWriter = new System.Xml.XmlTextWriter(soapStream, System.Text.Encoding.UTF8))
    {
        System.Xml.Serialization.SoapReflectionImporter soapRefImp =
            new System.Xml.Serialization.SoapReflectionImporter();
        System.Xml.Serialization.XmlTypeMapping xmlTypeMapping =
            soapRefImp.ImportTypeMapping(typeof(CarCollection));
        System.Xml.Serialization.XmlSerializer xmlSerializer =
            new System.Xml.Serialization.XmlSerializer(xmlTypeMapping);
        xmlWriter.WriteStartElement("carRoot");
        xmlSerializer.Serialize(xmlWriter, carCol);
        xmlWriter.WriteEndElement();
    }
}

Deserializing a SOAP XML

Deserializing an SOAP XML is pretty simple and similar to the serialization logic. You need to create an instance of “SoapReflectionImporter” class and using the “ImportTypeMapping” method of “SoapReflectionImporter” create an instance of “XmlTypeMapping” class. Once these things are done create an instance of “XmlSerializer” class by passing the “XmlTypeMapping” object as one of the parameters. After this call the Deserialize method of the “XmlSerializer” class. The sample code is pasted below.

System.Xml.Serialization.SoapReflectionImporter soapReflImp =
                        new System.Xml.Serialization.SoapReflectionImporter();
System.Xml.Serialization.XmlTypeMapping xmlTypeMap =
        soapReflImp.ImportTypeMapping(typeof(CarCollection));
System.Xml.Serialization.XmlSerializer xmlSerial =
        new System.Xml.Serialization.XmlSerializer(xmlTypeMap);
using (System.Xml.XmlTextReader xmlTextReader = new System.Xml.XmlTextReader("SoapFormat.xml"))
{
    /*Needed to read the root element. In the serialization code we have added the "carRoot" element.*/
    xmlTextReader.ReadStartElement("carRoot");
    CarCollection carColl = (CarCollection)xmlSerial.Deserialize(xmlTextReader);
    xmlTextReader.ReadEndElement();
}

One can see from the above code that we are using “ReadStartElement” method of “XmlTextReader” class. This is done because we have manually added the “carRoot” element by making use of “WriteStartElement” method of “XmlTextWriter” while serializing the object. If “ReadStartElement” method is not used then the following error will be thrown.

System.InvalidOperationException: "There is an error in XML document (1, 2)."
Inner exception - System.InvalidOperationException: "<carRoot xmlns=''> was not expected."

So that’s about SOAP serialization. Next we will see how to write custom serializers so that we can take control of serialization, till then try to learn more.

Sandeep

Reading from a configuration file in .NET.

2009-06-23T16:03:00.001+05:30

Recently I was working on a web application which had an exe added as a reference to the project. The exe had its own App.Config file where some setting related to the application was saved and these were read using the code below. Pretty straight forward code.

private static string userName = ConfigurationSettings.AppSettings["UserName"].ToString();
private static string userEmail = ConfigurationSettings.AppSettings["UserEmail"].ToString();

In the above code we are trying to retrieve value from the AppSettings section of the App.Config file of the application using the ConfigurationSettings class’ AppSettings property which is a namevalue collection object. The above approach is a deprecated method. Instead of the above approach, one can make use of the below code to retrieve the appsettings values.

private static string userName = ConfigurationManager.AppSettings["UserName"].ToString();
private static string userEmail = ConfigurationManager.AppSettings["UserEmail"].ToString();

ConfigurationSettings API has become obsolete and has been replaced with the ConfigurationManager class to read the configuration setting of an applicatioin. To read the application settings or AppSettings of an application one can make use of ConfigurationManager.AppSettings. But my problem was not related to the API becoming obsolete. The system was throwing error when the system was trying to read the configuration. The errors are pasted below.

The parameter 'exePath' is invalid.
Parameter name: exePath

An error occurred loading a configuration file: The parameter 'exePath' is invalid.
Parameter name: exePath

Object reference not set to an instance of an object.

The reason why these errors were thrown is that while we were trying to read the keys from the configuration file the key were actually not present in the “AppSettings” section.

As I said earlier the exe file was added as a reference in an ASP.NET web application and due to some reason when the exe code was accessed through the ASP.NET web application it was throwing error. The same exe application when executed independently was running without any exceptions.

On debugging it was found that, as the request was coming from the ASP.NET web application to the exe file the ConfigurationManager’ AppSettings property had values from the appSettings section of web.config file of the web application. But I wanted the appSettings values of the App.Config file of the exe application. The only solution to my problem was to read from the app.config file of the exe file. Below is the code to read from the configuration file.

string filePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, “Bin”);
/*If checking to check whether the bin folder exists. As this is a console application the exe can be copied to any place and can be executed. If that is the case there will be no bin folder. */
if (!Directory.Exists(filePath))
{
filePath = AppDomain.CurrentDomain.BaseDirectory;
}
/*As the request for this class can come from both exe and website we need to combine the paths. We are first retrieving the path using the AppDomain' BaseDirectory propety and then retrieving the exe name alone. Finally passing the combined file path to ConfigurationManager class. */
filePath = Path.Combine(filePath, Path.GetFileName(System.Reflection.Assembly.
GetExecutingAssembly().Location));
System.Configuration.Configuration theConfig = ConfigurationManager.
OpenExeConfiguration(filePath);

KeyValueConfigurationCollection configuration = theConfig.AppSettings.Settings;
userName = configuration["UserName"] == null ? string.Empty :
configuration["UserName"].Value;
userEmail = configuration["UserEmail"] == null ? string.Empty :
configuration["UserEmail"].Value;

In the above code I am using AppDomain class to retrieve the directory from where the application is executing itself. This approach was taken because the exe will run on its own or can be copied and pasted anywhere and it can run from there or as in my case the request can come from an ASP.NET application. If the exe is added as a reference in an ASP.NET web application, the exe will be copied to the bin folder of the ASP.NET application. So you can see there is a checking to see if there is a “Bin” folder, if there is one the app.config settings will be read from there else it will read from the base directory.

Once the file path along with the exe file name is properly formed we are using ConfigurationManager’ OpenExeConfiguration method to open the configuration file of the exe file. One thing to note here is that we are using “GetExecutingAssembly().Location” property and retrieving the file name and passing the application name along with the extension (.exe) to the OpenExeConfiguraiton method. There is no need to specify “app.config” file name. The reason is whenever an exe is successfully compiled it will create a config file with the same name with a .config extension. For e.g. if you have an exe named “one.exe”, if it is successfully compiled it will create a config file with “one.exe.config” as the name.

Once the config file is successfully opened using “OpenExeConfiguration” method it returns a Configuration object. After successfully retrieving the configuration object, in the next line we are getting the application’ settings using the “AppSettings.Settings” property. The “Settings” property returns a “KeyValueConfigurationCollection” object. Using KeyValueConfigurationCollection object one can read the values of the configuration file. In the above code we are using “configuration["UserName"]” to read the value stored against the “UserName” key. Here the “UserName” is the key. So that’ about reading configuration settings from a configuration file of an application.

Try to know more.

Sandeep

Difference between $get and $find

2009-06-05T13:04:00.001+05:30

In my previous blogs I have made use of $get and $find javascript methods. These are new shortcut methods available in ASP.NET AJAX. To use these methods one has include ScriptManager in an aspx page. What are these two methods all about? Lets see one by one.

$get

$get is the shortcut method for document.getElementById. If you put a break point in the $get function and step into the function you can see the following code.

From the above code one can infer that the signature of the shortcut method is something like this.

$get(id, element)

The function argument “id” takes a string value where one can pass the id of the element to be retrieved. “element” is an optional parameter, if passed the code will try to find a control inside the element if it supports getElementById else it will loop through all the child nodes and match the id of the child node with the id passed as the function argument. Below sample code shows the usage of the $get.

//Getting the ASP.NET server control' id using the ClientID.
var txtCntl = $get('<% =txtChange.ClientID%>');
//Getting a control which is not a server control
var divCntl = $get('contentDiv');
//Passing the id of the control as well the control in which the controls needs to be searched.
var dropDownCntl = $get('<% =ddCountries.ClientID %>', divCntl);

--Html tag for the above controls is pasted below--
<form id="form1" runat="server">
    <div id="contentDiv">
        <asp:DropDownList ID="ddCountries" runat="server">
        </asp:DropDownList>
        <asp:TextBox ID="txtChange" runat="server"></asp:TextBox>
        <asp:Button ID="Button1" runat="server" Text="Button" />
    </div>
    <asp:ScriptManager ID="ScriptManager1" runat="server">
    </asp:ScriptManager>
</form>

In the above code we have seen the different ways of retrieving a control using the $get function. If you see the javascript code pasted above one can see in the first line we are trying to retrieve a ASP.NET server control using inline server code where we are using ClientID property to retrieve the system generated ID for the server control. In the second line we are using the id of the Div tag to retrieve the div control. Finally in the third line we are making use of ClientID and then passing the div control retrieved in the second line as the second argument to $get function. What happens in the third approach is that the $get function tries to find the control inside the div tag. So that’ about the $get function.

$find

$find is the shortcut method for “Sys.Application.findComponent(id, parent)”. The function takes id as a string parameter and also the control in which the component needs to be searched. The second parameter is optional. If provided it will look for the component in the component or element passed as an argument. The signature of the method is as follows.

$find(id, parent)

The method looks for components registered with the addComponent javascript method. If you put a debug point and step into the function you can see the below code.

From the above code you can see that the code first checks whether the parent element is of type IContainer if it is then it tries to find the component within the parent component else it returns the component from the _components array in the Sys.Application object.

When to use $get and $find?

$get javascript shortcut method can be used instead of document.getElementById whereas $find can be used to find extender controls. If you use $get to retrieve extender controls like ValidatorCalloutExtender, AutoCompleteExtender etc it will return null.

So that's the difference between $get and $find.