Today, I was working on a UI enhancement task where I had to do some DOM manipulation. Basically task was changing color of some SPAN elements in DOM depending on their value like if it’s value is XXX then show in RED color and so on. As always I was using IE to test my Java script code written to do the job. In JS code, I used “innerText” property of SPAN element to get the text of that element and then did the comparison to change the color and It worked fine. When I ran same JS code on Mozilla, it didn’t run (I mean it got executed but didn’t changed color of SPAN elements to RED L) . On debugging the script, I was surprised to see value of innerText property being returned null. When googled around it and found that only Mozilla doesn’t support this property L. Mozilla has another property “textContent” which has same value as innerText in other browsers.

Solution was simple, use an ORing of both the values instead of putting if-else block in code to use textContent if the user is running Mozilla or innerText for any other browser.

var txtName = clientNameElement.innerText || clientNameElement.textContent;

I picked up this solution from here. This link provides a good comparison of various DOM properties on different browsers that is what works and what not J.

Hope it helps some of you while writing code to cater to multiple browsers J

I have been using Microsoft Office 2007 since last one and half years and frankly speaking “I’m lovin’ it”. Be it quick style feature of Word 2007 or ShapeStyle, WordArt Style of Powerpoint 2007, I have been using them extensively in this period. The new interface is so usable at the same time providing me lots of, out of the box available formatting features like table style, document templates n so on.

Ok so enough of praises for Office 2007, after all this post is not about why I like it. There are plethora of resources, posts, videos available over net describing the above mention benefits (features) of office 2007. This post is about creating and publishing a blog entry right from Word 2007 document. Since last few days I have been trying to be little active with my blog and write something to do justice with the its tagline “What I learned today“. Last week I was reading Gaurav’s blog and there he had a post about blogging from Word itself. So far I have been using Windows Live Writer to do most of my blogging related stuff(which is minimal BTW J), which is a great tool for blogging but it didn’t allowed me to format my post the way I wanted them to for ex putting quotes, creating colored tables for comparison related stuff etc. After reading gaurav’s post, I myself thought to give a spin to this feature of publishing content from word.

So here is the post for my tryst with blogging in Word 2007.

Enable publishing form word

After registering the blog a new word document will open and you are good to go. I tried various formatting setting, picture formatting. So far so good. I am going to use word now instead of Livewriter.

"STATE as a noun can be described as "the condition of a person or thing, as with respect to circumstances or attributes".  In ASP.NET world, State of a control or a page is what it looks like, what its value is and what its value was before the page was posted back."

Since HTTP is stateless, to maintain state across postbacks in ASP.NET, some state management techniques are used. In ASP.NET state management can be categorized in two types depending on the location where state is being kept:

1. Client Side: Client side state management involves keeping the state data on the client end, either on client machine or the browser. There are various mechanisms to maintain state on client side like Cookies, ViewState, Hidden Fields, Control State, Query strings etc.
2. Server Side: Server side management is keeping state on a different machine be it database or file system on a different computer. Server side state management can be done using Application State, Session state etc. this data can be  stored in the server process or in a database or server file system.

For detailed information about different option available for state management in ASP.NET, please refer this link for MSDN. This link also gives a good comparison of various state management techniques with  their pros n cons.

ViewState is the first thing that come to mind when dealing with postbacks in ASP.NET.

ViewState

In simple terms, ViewState is keeping information about page in a non-readable i.e. serialized way with the page itself. In ASP.NET, view state is kept in a hidden field name _VIEWSTATE on the page. So every time the page loads after the postback this serialized data is read and appropriate state is loaded into the controls.

To understand how viewstate is saved and loaded, one should know the page life cycle i.e. the steps a request, for loading a page, goes through before a page is fully rendered into the browser. This link on MSDN explains Page life cycle along with a good overview of what view state is.  This post by Dave Reed gets under the hood of view state and explains the nuances of view state very well. I would recommend reading the above mention post to every one. That post has been the best link I have come across on view state.

As mentioned above, View state is kept in a hidden field _VIEWSTATE on the page. So every time the page is posted back to the server or retrieved from server, the content of View state also travel along with page content. In turn contributing to usage of network resources. Generally, developers have tendency to keep view state enabled for controls on their page. which unknowingly keeps growing the page size. This means as page size grows, it would take longer for the page to completely render itself.

Problem comes when the page size grows inordinately and waiting time for the end user to see the completely rendered page is too high. There are recommendation that one should use viewstate as minimally as possible to ensure the page size is with in limits. But sometime scenario enforces the developer to use viewstate in his/her page. In such cases following are some of the guideline/approaches to keep view state size in check.

1. Enable view state for a control only when absolutely necessary: Set the EnableViewState attribute for the control to false explicitly, when you are sure that you do not require to keep state for that control.
2. Don’t save large datasets into view state: Whenever possible keep the datasets and big data tables in cache or say session so that view state is small.
3. Use IIS Compression: Internet Information Services(IIS) has the feature to provide compression for the pages it serves as response to the requests received. You can configure the IIS on your server to compress the appropriate websites or pages in the website. For detailed information about how to configure the IIS configuration on your server, please read this post by Scott Forsyth.  There is one another post by Shivprasad koirala, which is an extension of the post by Scott Forsyth, it also explains IIS compression in great details along with it also provides some comparison statistics data about what level of compression is good and for what type of pages one should avail this
4. Using old ASP.NET 1.1 approach for storing the view state on server: In Page life cycle there are two steps available which do the job of fetching the view state from the hidden field and putting the view state content back into the hidden field it was stored. These methods are LoadPageStateFromPersistenceMedium and SavePageStateToPersistenceMedium. These methods are virtual methods from the Page class. A simplest approach would be to store the viewstate in session itself. Following code snippet shows how this could be done by overriding the two above mentioned methods and storing the viewstate in session after serializing and loading the viewstate from session again after desterilizing it. Serialization and deserialization is done using LosFormatter class. One can use any of the available formatters, BinaryFormatter, SOAPFormatter etc., for serializing the viewstate content. Content is stored in session with SessionID being the key.

protected override object LoadPageStateFromPersistenceMedium ()

{

    return (new LosFormatter().Deserialize ((string)Session[Session.SessionID]));

}
protected override void SavePageStateToPersistenceMedium (object state)

{

    LosFormatter los = new LosFormatter();

    los.Serialize (sw, state);

    string vs = sw.ToString ();

    Session[Session.SessionID] = vs;

}

An improvement in above mentioned approach could be to apply the compression on the viewstate content before storing them in session and decompressing the session content before restoring the viewstate. Following code does exactly this. This code introduces one more step, between storing and retrieving the view state from session, by compressing and decompressing the content. This approach again leads to save some more bandwidth.

        protected override object LoadPageStateFromPersistenceMedium()

        {

            string viewState = (string)Session[Session.SessionID];

            byte[] bytes = Convert.FromBase64String(viewState);

            bytes = Compressor.Decompress(bytes);

            LosFormatter formatter = new LosFormatter();

            return formatter.Deserialize(Convert.ToBase64String(bytes));

        }

        protected override void SavePageStateToPersistenceMedium(object state)

        {

            LosFormatter formatter = new LosFormatter();

            StringWriter writer = new StringWriter();

            formatter.Serialize(writer, state);

            string viewStateString = writer.ToString();

            byte[] bytes = Convert.FromBase64String(viewStateString);

            bytes = Compressor.Compress(bytes);

            Session[Session.SessionID] = Convert.ToBase64String(bytes);

        }

   5. ASP.NET 2.0 approach for saving viewstate on server:

In ASP.NET 2.0, ViewState is saved by a descendant of PageStatePersister class. This class is an abstract class for saving and loading ViewsState and there are two implemented descendants of this class in .Net Framework, named HiddenFieldPageStatePersister and SessionPageStatePersister. By default HiddenFieldPageStatePersister is used to save/load ViewState information, but we can easily get the SessionPageStatePersister to work and save ViewState in Session object. The only thing to do this is to override PageStatePersister property of Page class and ask it to return an instance of SessionPageStatePersister class:

protected override PageStatePersister PageStatePersister

{

    get

    {

        return new SessionPageStatePersister(Page);

    }

}

The PageStatePersister class can be inherited to also created custom storage mediums for session state. The PageStatePersister class has two methods Load() and Save() which can be used to provide custom loading and saving media for ViewState.

public class StreamPageStatePersister : PageStatePersister

    {

        public StreamPageStatePersister(Page page)

            : base(page)

        {

        }

            public override void Load()

            {

            Stream stateStream = GetSecureStream();

            // Read the state string, using the StateFormatter.

            StreamReader reader = new StreamReader(stateStream);

            IStateFormatter formatter = this.StateFormatter;

            string fileContents = reader.ReadToEnd();

            // Deserilize returns the Pair object that is serialized in

            // the Save method.

            Pair statePair = (Pair)formatter.Deserialize(fileContents);

            ViewState = statePair.First;

            ControlState = statePair.Second;

            reader.Close();

            stateStream.Close();

            }

        public override void Save()

        {

            if (ViewState != null || ControlState != null)

            {

                if (Page.Session != null)

                {

                    Stream stateStream = GetSecureStream();

                    StreamWriter writer = new StreamWriter(stateStream);

                    IStateFormatter formatter = this.StateFormatter;

                    Pair statePair = new Pair(ViewState, ControlState);

                    // Serialize the statePair object to a string.

                    string serializedState = formatter.Serialize(statePair);

                    writer.Write(serializedState);

                    writer.Close();

                    stateStream.Close();

                }

                else

                    throw new InvalidOperationException("Session needed for StreamPageStatePersister.");

            }

        }

    }

Then a PageAdapter can be used to use this persister

public class MyPageAdapter : System.Web.UI.Adapters.PageAdapter

{

    public override PageStatePersister GetStatePersister() {

        return new Samples.AspNet.CS.StreamPageStatePersister(Page);

    }

}

This adapter can be configured via a .browser file placed in App_Browsers folder locally with the web site directory.

<browsers>

    <browser refid="Default" >

        <controlAdapters>

            <adapter 

                controlType="System.Web.UI.Page"                            

                adapterType="MyPageAdapter" />

        </controlAdapters>

    </browser>

</browsers>

This all above content was related to removing/reducing the Viewstate getting transferred over network. But there is still one more type of state “ControlState”. In layman’s terms, Its the minimal information that a control needs to render and function itself properly after a postback. A more apt definition from MSDN is:

Control state, introduced in ASP.NET version 2.0, is similar to view state but functionally independent of view state. A page developer can disable view state for the page or for an individual control for performance. However, control state cannot be disabled. Control state is designed for storing a control’s essential data (such as a pager control’s page number) that must be available on postback to enable the control to function even when view state has been disabled. By default, the ASP.NET page framework stores control state in the page in the same hidden element in which it stores view state. Even if view state is disabled, or when state is managed using Session, control state travels to the client and back to the server in the page. On postback, ASP.NET deserializes the contents of the hidden element and loads control state into each control that is registered for control state.

As it is mentioned in the above description, that ControlState will be traveling with the page all the time. There may come a requirement where we want to have it stored somewhere else other then the page hidden fields. While searching for methods to reduce the viewstate size, i stumbled across this post by SZOKELIZER, which describes a way to store the ControlState in session as well. ASP.NET provides a switch “RequiresControlStateInSession” which allows to store the control state in session rather then the page itself. So for the sake of completeness I am putting the code that needs to be put to enable storing the control state in session from the above mentioned post.

<system.web>

    <browserCaps>

      <case>

        RequiresControlStateInSession=true

      </case>

    </browserCaps>

  </system.web>

Conclusion

In this post I have written about different mechanisms to reduce size of viewstate that travels along with an asp/aspx page every time. I have tried to covered few of the approaches that can be used but I am sure there can be many more. One such approach suggested by a friend of mine is using HttpHandlers to cut the viewstate from the request and restore it back. I am working on a poc for this. I will post it once it is complete. Please do post a comment, if you have come across any other way to tackle this or if there is some correction in approaches I have described above.

Attackers try to exploit smallest possible hole into the security of a website. A common and widely used method is script injection attack or cross site scripting where attacker tries to put some script as input to the website and tries to damage the system. A simplest example could be passing a java script function that redirects every request to a page to some other site next time onwards or passing a SQL DML statement which deletes/updates record into the database.

ASP.Net provide some measure to mitigate this risk of script injection. One of such technique is validating each and every input entered by the user before passing it on the server automatically. In this approach IIS parses the input before it is sent to the worker process and checks it for potential dangerous characters lie <, > etc. If any of such character is found in the input request, an exception is thrown, thus saving the site from a possible attack.

The exception thrown is

“A potentially dangerous Request.Form value was detected from the client”

In ASP.NET this feature can be applied per page basis or for the entire site depending on the requirement. To enable input request validation for the entire site, set validateRequest attribute of page section in web.config to true.

<configuration>

    <system.web>

        <pages validateRequest="false" />

    </system.web>

</configuration>

Similarly, to override the request validation or enable/disable request validation on a page ValidateRequest attribute of Page directive can be set to true/false respectively. Setting this attribute to true instructs the IIS to check the sanity of the incoming request before passing it on.

So this approach won’t let any script to pass through. But there are situations where you need to take a script or the prohibited characters like <,> as input from user, at the same time preventing a misuse of this opportunity of script injection.

A commonly used approach in ASP.NET for this scenario is:

1. Set ValidateRequest to false for that page.
2. Encode the input entered by the end user using Server.HtmlEncode(): Encoding ensures that all the stop words(potentially harmful characters) are converted to an equivalent HTML character encoding e.g. “<” is converted to “&lt;” etc.

I had a similar requirement, few days back, when in our application on “contact us” page, We wanted to allow user to enter html scripts into a text box. So we disabled the ValidateRequest attribute to false and used Server.HtmlEncode() method to encode the entered input. But at the same time we didn’t wanted the user to pass something malicious through the query string or the cookies. ASP.NET also provides a method on the Request object named ValidateInput(), which validates the request input passed by the client to the server. And if something fishy is found in the request an HttpRequestValidationException exception is thrown. And this is where the confusion gets in.

As per MSDN, Request.ValidateInput() method ….

The HttpRequest class uses input validation flags to track whether to perform validation on the request collections accessed through the Cookies, Form, and QueryString properties. The ValidateInput method sets these flags so that when the get accessors for the Cookies, Form, or QueryString property are invoked, input validation is performed. Validation works by checking all input data against a hard-coded list of potentially dangerous data.

If the validation feature is enabled by page directive or configuration, this method is called during the page’s ProcessRequest processing phase. The ValidateInput method can be called by your code if the validation feature is not enabled.

As this definition says that ValidateInput method does nothing but sets some flags indicating that all access to user input must be validated before using it. But normally developer tend to call Request.ValidateInput() method and then expect it to throw the HttpRequestValidationException exception, which will not happen since this method doesn’t throw any exception, rather any access now onwards to input will throw the above mentioned exception.

Lets disassemble the Request.ValidateInput method.

public void ValidateInput()

{

    this._flags.Set(1);

    this._flags.Set(2);

    this._flags.Set(4);

    this._flags.Set(0x40);

    this._flags.Set(0x80);

}

As shown in the above code snippet, this method has just some set methods calls. Actually these method set a flag for one of the input approach that can be used by the client. Like querystring, form input , cookie etc.

So what does this setter method do?? This method is merely an indicator for the getters methods of each of the request fields to check the sanitation of the value before returning the value to the requestor and if there is some invalid input then throw the HttpRequestValidationException.

So to check for invalid input in Form values, we need to access form values collection of the request as Request.Form after the call to Request.ValidateInput(). Following is a sample code for validating Form values,

String firstName = string.Empty;

try

{

    Request.ValidateInput();

    //Access the Form value collection. So if there is any non complient input entered by user.. It will throw an exception

    System.Collections.Specialized.NameValueCollection nvc = Request.Form;


    firstName = txtName.Text.Trim();

}

catch(HttpRequestValidationException)

{

    firstName = HttpUtility.HtmlEncode(txtName.Text.Trim());

}

here line in yellow color will throw an exception if at all there is some bad data in the input. Then in catch we can use HtmlEncode() to encode the user input.

Similar approach can be used while accessing cookies or QueryString.

Ever encountered “This page contains both secure and nonsecure items. Do you want to display the nonsecure items? ” in IE. Well I do and this pesky popup keeps bugging me now n then. Till today, I never bothered about it. I used to click “Yes” no matter what . I know it’s not always safe to do it but who cares

Today I was assigned a bug, in the application I am working on, which says that users are seeing this popup so many times and they are not happy about it. That got me thinking people do care about these pop ups as well .

Ne way, I had to find a solution to get rid of this warning. So after little Binging and Googling I found the solution. So thought about writing my findings though they are available in top 10 search results

The reason for this warning is that you are visiting a secure site (HTTPS site) and somewhere behind the scenes that site or page is trying to access a non secure resource be it a complete page or some image. That makes the browser assume that since you are inside a secure site, you should not be getting anything that’s not secure. Like many a times https pages have some images whose source is http for example http://mmyserver/myimages .

There are two ways you can get rid of this warning

1. Change all reference of http to https in the page.
2. Lower your guard in IE: IE has a setting which decide what the browser behavior in case of a non secure content coming while browsing a secure page. This setting is in “IE ==> Tools ==> Internet Options ==> Security Tab ==> Click Custom Level button” this will open up a list of options for various security settings for IE. Scroll this list to search for “Display Mixed Content” option. The “Prompt” radio option is selected by default. Change it to “Enable” option and click OK. and you are done. The change will take effect immediately.

Following are some of the links which helped me to solved me the issue:

1. http://ask-leo.com/can_i_get_rid_of_the_this_page_contains_both_secure_and_nonsecure_items_warning.html

2. http://www.sslshopper.com/article-stop-the-page-contains-secure-and-nonsecure-items-warning.html?jn948e2cf0=2#jotnav948e2cf0db15fcce0a996d225ead01c0

3. http://www.velocityreviews.com/forums/t152692-this-page-contains-both-secure-and-nonsecure-items.html

4. http://blogs.msdn.com/jorman/archive/2006/02/06/526087.aspx

5. http://www.wallpaperama.com/forums/windows-disable-this-page-contains-both-secure-and-nonsecure-items-t274.html

6. http://www.aspdeveloper.net/tiki-index.php?page=HTMLTipsSSLNonSecureWarning

Pagination is a must have feature when it comes to display a list of item. List could be collection of search results, a tabular display of names etc etc. When the list is small, pagination is not something we should be worried about, But imagine having a list with 100’s of items to show then displaying all of them at once on a page is not a good idea.

• Viewer of that page have to scroll down a lot if the list if too long
• Page becomes slower since there are lots of DOM elements on the page

So developers tend to display a small number of items at once to the viewer and then proving him/her the option of navigating to different pages. There are two ways once can implement paging

1. Server side paging: Developer can get only a fixed number of records from the server and display then to the viewer and whenever viewer wants to navigate to a different page, a new request demanding the items from that particular page can be send to the server. In turn server can return records from that page only.
2. Client side paging: Depending on the scenario developer can also do the job of showing pages on the client side as well i.e. he/she may request all the items at once and then showing only a set of them to the viewer and providing user with the links to other pages using any scripting language.

I had a situation where it was not possible to have server side pagination due to restriction of the framework I was coding against. So I had no choice but to go with client side paging. I was implementing a search functionality where I would be searching against the lucene index to get the results and then showing those results to the viewer. search results will be displayed a html table. each row in the result table will be used to display one search result. Each search result will have some predefined fields and a summary for that results. Viewer will have an option to show and hide the summary of the result. So one requirement was to have different number of items per page depending on whether summary is visible to the viewer or not.

I took the following approach:

After getting results from server, I used JavaScript to create DOM elements for each of the search results returned. After all the results are created on the page, pagination code was called to show the first page and the pager.

To start I created a JS class named “Pager” which will have all the methods related to the navigation among pages. Pager class had following members:

• tableName : Name of the table on which pagination has to be applied.
• itemsPerPage : Number of items to show when summary field is visible.
• itemsWithoutSmry : Number of items to show when summary field is not visible to the viewer.
• currentItemPerPage : Number of items currently visible. This value will be equal to either itemsPerPage or itemsWithoutSmry.
• currentPage : current page in the table.
• pages : Total number of pages in the table.

All the above field will be initialized to some default values when the Object of Pager call will be created.

Initialization of the pager

This method will initialize the pager object field pages by using the total records and items to shown on page. Following code snippet is the init() method.

//initialize the pager

  this.init = function() {

        //check if table exists in the dom

        if(document.getElementById(tableName) != null)

        {

                // get the total number of rows in the table

            var rows = document.getElementById(tableName).rows;

            var records = (rows.length - 1);

                // Calculate the number of pages

            this.pages = Math.ceil(records / this.itemsPerPage);

                // set the flag to indicate initialization is complete

            this.inited = true;

        }

   }

Showing records of a particular page

To do this I will iterate through the rows of the table to show/hide the visibility of these rows depending on the page viewer has requested. Following code snippet shows the methods that do this.

//Show record from a start index to an end index

this.showRecords = function(from, to) {

        // check if table exists in the DOM

        if(document.getElementById(tableName) != null)

        {

        //Get rows in the table and then set the visibility of the rows between 'from' and 'to'

            var rows = document.getElementById(tableName).rows;

            // i starts from 1 to skip table header row and hide rows other then the current page

            for (var i = 1; i < rows.length; i++) {

                if (i < from || i > to)

                    rows[i].style.display = 'none';

                else

                    rows[i].style.display = '';

            }

        }

    }

// Method to show a particular pager

 this.showPage = function(pageNumber) {

    // check if initialization is done

        if (! this.inited) {

            alert("not inited");

            return;

        }

        //change the CSS style of the old page

    //each page number indicator in the pager has a naming convention like tablename+pg+pageindex

        var oldPageAnchor = document.getElementById(this.tableName+'pg'+this.currentPage);

        if(oldPageAnchor)

        oldPageAnchor.className = 'pg-normal';

        //change the style of the current page

        this.currentPage = pageNumber;

        var newPageAnchor = document.getElementById(this.tableName+'pg'+this.currentPage);

        if(newPageAnchor)

        newPageAnchor.className = 'pg-selected';

       //calculate current page records index

        var from = (pageNumber - 1) * this.currentItemPerPage + 1;

        var to = from + this.currentItemPerPage - 1;

    //show the records

        this.showRecords(from, to);

    }   

Navigating to Next and Previous pages

//show previous page

    this.prev = function() {

        if (this.currentPage > 1)

            this.showPage(this.currentPage - 1);

    }

    //show next page

    this.next = function() {

        if (this.currentPage < this.pages) {

            this.showPage(this.currentPage + 1);

        }

    }

Showing the pager bar

Following code snippet contains javascript method which will create a div at the end of table containing number from 1 to the total number of pages in the table along with prev and next page links. each link will have a onclick javascript function call to the above mentioned functions.

//show the pager bar

// param : @pagerName: name of the pager object

//  param : @positionId: Id of the div in which the page has to be shown 

    this.showPageNav = function(pagerName, positionId) {

      // Check if the pager object has been initialized

      if (! this.inited) {

        alert("not inited");

        return;

      }

      // check if the div exisits in DOM 

      if(document.getElementById(positionId) != null)

      {

        var element = document.getElementById(positionId);

        // create prev page link with call to prev() method

        var pagerHtml = '<b><span onclick="' + pagerName + '.prev();" class="pg-normal"> &#171 Prev </span> | ';

        // create numeric page number links

        for (var page = 1; page <= this.pages; page++)

              pagerHtml += '<span id="'+this.tableName+'pg' + page + '" class="pg-normal" onclick="' + pagerName + '.showPage(' + page + ');">' + page + '</span> | ';

        // Create next page link with call to next() method

        pagerHtml += '<span onclick="'+pagerName+'.next();" class="pg-normal"> Next »</span> </b>';

        // chnage the inner html of the pager Div 

        element.innerHTML = pagerHtml;

        }

    }

Adjusting the record count per page with the Summary visibility

I added a method to the pager class which takes a Boolean parameter denoting the visibility status of the summary content as input and based on this parameter it changes the current page size. Following code snippet shows the same:

//adjust page according to summay div visibility

// param : @isSummaryShown = Visibility status of the summary content for the item

    this.adjustPager = function(isSummaryShown)

    {

      //change the pagesize

      if(isSummaryShown)

      {

        this.currentItemPerPage = this.itemsPerPage;

      }

      else

      {

        this.currentItemPerPage = this.itemsWithoutSmry;

      }

      //rebuild pager

      if(document.getElementById(tableName) != null)

      {

          var rows = document.getElementById(tableName).rows;

          var records = (rows.length - 1);

          this.pages = Math.ceil(records / this.currentItemPerPage);

        }

    this.showPageNav("pagerObj", 'pageNavPosition_Results');

    this.showPage(1);

    }

Creating and using Instance of the Pager Class

following line shows the signature for the pager class

function Pager(tableName, itemsPerPage, pageSizeWithoutSummary)

after the page object is created it must be first initialized, then the pager bar should be created followed by showing the page.

Following code snippet shows this

// create a pager obejct by passing tablename, page size

var pagerObj = new Pager('table_AllResults', 10, 15);

// init the pager object

pagerObj.init();

//show the pager bar for itens without summary

pagerObj.adjustPager(false);

//show first page

pagerObj.showPage(1);

I will be uploading a demo soon.

If you have some better way to implement the pagination then please drop a comment. 

–

While surfing around I can across a term called “null-coalescing operator”. After searching about it, I came to know that C# has an operator ?? . well I didn’t new about it before so thought of writing about it.

MSDN says

The ?? operator is called the null-coalescing operator and is used to define a default value for a nullable value types as well as reference types. It returns the left-hand operand if it is not null; otherwise it returns the right operand.

Example:

int? x = null;

string str = "Hello World !!";


int y = x ?? -99; // Here Y will be -99 since X is null

string newStr = str ?? "Default Hello World !!"; // here newStr will be "Hello World !!"

PS: This operator reminded me of similar functions available in SQL Server like ISNULL, COALESCE

–

Yesterday, a team mate of mine sent an email regarding a problem with his Visual Studio 2005. ASP.NET web server wasn’t allowing him to debug any Web services. Following is the complete description of his problem:

Summary

In short, the ASP.NET 2.0 development web server (webdev.webserver.exe) on my machine broke after I installed and uninstalled NDoc some days ago. IIS still works fine. I’ve tried re-registering ASP.NET 2.0 (aspnet_regiis –r from the 2.0 directory) to no avail. Other than re-installing VS 2005, could you recommend a quick fix?

Problem Description

I am on XP. I had VS 2005 with v2.0 of the framework. Then I installed NDoc recently and that supports only v1.1, so it installed v1.1 on top of v2.0. That is fine because both versions can co-exist but what it did was screw up some settings with:
a) The web server that comes with ASP.NET, the one you run your web services on in debug mode.
b) SQL Server’s active CLR settings (but this isn’t bothering me as much)
c) IIS settings (but I fixed this by re-registering IIS with 2.0)
What’s bothering me to the hilt now is the broken ASP.NET web server won’t allow me to debug my Web services or even have another project in the same solution create a web reference to it.
I can’t generate proxies in Visual Studio because of this, nor can I set a web reference to a web service in the same solution (as it involves generating a proxy).
Note that I can call wsdl.exe though. My web services compile, and if I generate a proxy myself through wsdl.exe, deploy my WS locally on IIS, and change the url in the proxy’s constructor to my locally deployed WS, and add the proxy to my client project, it all works fine.

But I don’t want to deploy my service yet. I just want all projects in the same solution referencing the ws like well-behaved little kids.
When I do try to create a web reference to the WS project in my solution, I keep getting this error:
Server Error in ‘/’ Application.
——————————————————————————–
Parser Error
Description: An error occurred during the parsing of a resource required to service this request. Please review the following specific parse error details and modify your source file appropriately.
Parser Error Message: Could not create type ‘DaWS.PhoneDirectory’.
Source Error:
Line 1:  <%@ WebService Language="C#" CodeBehind="PhoneDirectory.asmx.cs"
Line 2:  Class="DaWS.PhoneDirectory" %>
Source File: /PhoneDirectory.asmx    Line: 2
——————————————————————————–
Version Information: Microsoft .NET Framework Version:2.0.50727.3082; ASP.NET Version:2.0.50727.3082
It’s been nagging me for days now and I’ve been managing with deploying in IIS.
Other than re-install Visual Studio, does anyone have a better solution?
Here’s what the Event Log says:
Event Type:    Warning
Event Source:    ASP.NET 2.0.50727.0
Event Category:    Web Event
Event ID:    1310
Date:        06/05/2009
Time:        12:04:33 AM
User:        N/A
Computer:    ABCD
Description:
Event code: 3006
Event message: A parser error has occurred.
Event time: 06/05/2009 12:04:33 AM
Event time (UTC): 05/05/2009 6:34:33 PM
Event ID: c41a610193fa4c2e810dad096709b0b0
Event sequence: 4
Event occurrence: 1
Event detail code: 0
Application information:
    Application domain: a54e0deb-1-128860220726250000
    Trust level: Full
    Application Virtual Path: /
    Application Path: C:\Me\rnd\DotNet\DoIndexersGetSerialized\DaWS\
    Machine name: ABCD
Process information:
    Process ID: 660
    Process name: webdev.webserver.exe
    Account name: Domain\Me

Some one finally caught the issue, following are his observations and solution:

Just wondering if you are using a fixed port or not for the web service that you try to reference. Because Web Dev by default always host the app on different port and if that the case you will not be able to get it working ever.

If you are not using the fixed port I would suggest you to use the “External Tool” options present in the VS’s Tool menu and create a fixed web dev location that is associated with you web service and you should be able get it working.

I may be telling you the thing that you might have tried but just incase if you haven’t please give it a try.

Please have a look at this URL and probably give you the solution you are looking for.

http://weblogs.asp.net/scottgu/archive/2005/11/21/431138.aspx

This did the trick. The problem was solved. So I thought to write it here as someone else may face the same issue.

Its summer time in India and its hard to resist drowsiness in the afternoon specially when you had a heavy lunch. So this afternoon while I was trying to take a nap, no one was watching , a friend of mine pinged me on IM, and says “dude, can’t I pass an object as ref inside a foreach loop?”, well my first reaction was “of course you can!!! “ but then I realized that its an iterator  and I can’t modify an object I am iterating on.

I opened a new instance of Visual Studio and create a new console application. In this application created a new class named testref with just two fields, one string and another one an int. In the main method created a generic list of type testref and filled it with five testref object. Then tried to loop through it and pass the loop variable as ref in a function. He was right, C# compiler throws an error “Cannot pass ‘xxyzobj’ as a ref or out argument because it is a ‘foreach iteration variable’”. following snippet shows the initial set of code

 class Program

    {

        class testref

        {

            public string val { get; set; }

            public int a {get;set;}


            public testref(string s)

            {

                val = s;

                a = 0;

            }

        }


        static void Main(string[] args)

        {

            List<testref> testcol = new List<testref>();


            testcol.Add(new testref("One"));

            testcol.Add(new testref("two"));

            testcol.Add(new testref("three"));

            testcol.Add(new testref("four"));

            testcol.Add(new testref("five"));


            foreach (testref s in testcol)

            {

               MethodWithRef(ref s);

            }


            Console.ReadLine();


        }


        static void MethodWithRef(ref testref str)

        {

            str.val = str.val + " not";

            str.a = (new Random()).Next();

        }


}

In above code snippet, line in yellow will give the compilation error. Since this is a C# complier restriction there are couple of workaround to this situation.

• Have a temporary variable and then pass this variable as the ref parameter in the method:

testref tempObj;

foreach (testref s in testcol)

{

    tempObj = s;

    MethodWithRef(ref tempObj);

}

• Use List.ForEach() method to apply an action on all the objects in the list:

// Inside the main method pass the function name 

// you want to apply on each object

testcol.ForEach(MethodWithoutRef);


//Method to be applied on all the objects

static void MethodWithoutRef(testref str)

{

   str.val = str.val + " not";

   str.a = (new Random()).Next();

}

So that was it.. problem was solved…

PS: If you have some more ways this can be solved, Please do share.

–

Manoj

Well nowadays everyone says, its economic downturn these days.. World economy is going through troubled times.. World is under recession … so on n so forth.. All headlines related to this have one word in common . CREDIT CRISIS .. I always wondered how it all started… So while stumbling across the web found 2 videos giving a good visualization and answer to the big question … How It all started…? so thought of sharing these with all..

–