ASP.NET Caffe

WCF Security Guide

2011-09-28T03:46:00.000-07:00

Note: The content is procured from OWASP

From OWASP

From WCF 3.5 Security Guidelines

(@Codeplex by J.D. Meier , Jason Taylor , Prashant Bansode , Carlos Farre, Madhu Sundararajan, Steve Gregersen.)

Design Considerations

Design your service as a wrapper
If you are coming from ASMX then use basicHttpBinding to support your existing clients
If you are coming from DCOM then, use netTcpBinding
If your clients are deployed within intranet then choose transport security
If your clients are deployed over the internet then choose message security
Know your Authentication options
Know your binding options
If you need to Interop with non MS clients, use basicHttpBinding or wsHttpBinding
If your non-MS clients understand WS stack, use wsHttpBinding

Auditing and Logging

Use WCF auditing to audit your service
If non-repudiation is important, consider setting SuppressAuditFailure property to false
Use message logging to log operations on your service
Instrument for user management events
Instrument for significant business operations
Protect log files from unauthorized access
Do not log sensitive information

Authentication

Know your authentication options
Use Windows Authentication when you can
If you support non-WCF clients using windows authentication and message security, consider using the Kerberos direct option
If your users are in AD, but you can’t use windows authentication, consider using username authentication
If you are using username authentication, use Membership Provider instead of custom authentication
If your users are in a SQL membership store, use the SQL Membership Provider
If your users are in a custom store, consider using username authentication with a custom validator
If your clients have certificates, consider using client certificate authentication
If your partner applications need to be authenticated when calling WCF services, use client certificate authentication.
If you are using username authentication, validate user login information
Do not store passwords directly in the user store
Enforce strong passwords
Protect access to your credential store
If you are using Windows Forms to connect to WCF, do not cache credentials

Authorization

If you store role information in Windows Groups, consider using the WCF PrincipalPermissionAttribute class for roles authorization
If you use ASP.NET roles, use the ASP.NET Role Provider
If you use windows groups for authorization, use ASP.NET Role Provider with AspNetWindowsTokenRoleProvider
If you store role information in SQL, consider using the SQL Server Role Provider for roles authorization
If you store role information in ADAM, use the Authorization Store Role Provider for roles authorization
If you need to authorize access to WCF operations, use declarative authorization
If you need to perform fine-grained authorization based on business logic, use imperative authorization

Binding

If you need to support clients over the internet, consider using wsHttpBinding.
If you need to expose your WCF service to legacy clients as an ASMX web service, use basicHttpBinding
If you need to support remote WCF clients within an intranet, consider using netTcpBinding.
If you need to support local WCF clients, consider using netNamedPipeBinding.
If you need to support disconnected queued calls, use netMsmqBinding.
If you need to support bidirectional communication between WCF Client and WCF service, use wsDualHttpBinding.

Configuration Management

Use Replay detection to protect against message replay attacks
If you host your service in a Windows service, expose a metadata exchange (mex) binding
If you don’t want to expose your WSDL, turn off HttpGetEnabled and metadata exchange (mex)
Manage bindings and endpoints in config not code
Associate names with the service configuration when you create service behavior, endpoint behavior, and binding configuration
Encrypt configuration sections that contain sensitive data

Exception Management

Use structured exception handling
Do not divulge exception details to clients in production
Use a fault contract to return error information to clients
Use a global exception handler to catch unhandled exceptions

Hosting

If you are hosting your service in a Windows Service, use a least privileged custom domain account
If you are hosting your service in IIS, use a least privileged service account
Use IIS to host your service unless you need to use a transport that IIS does not support

Impersonation and Delegation

Know the impersonation options
If you have to flow the original caller, use constrained delegation
Consider LogonUser when you need to impersonate but you don’t have trusted delegation
Consider S4U when you need a Windows token and you don’t have the original caller’s credentials
Use programmatic impersonation to impersonate based on business logic
When impersonating programmatically be sure to revert to original context
Only impersonate on operations that require it
Use OperationBehavior to impersonate declaratively

Input/Data Validation

If you need to validate parameters, use parameter inspectors
If your service has operations that accept message or data contracts, use schemas to validate your messages
If you need to do schema validation, use message inspectors
Validate operation parameters for length, range, format and type
Validate parameter input on the server
Validate service responses on the client
Do not rely on client-side validation
Avoid user-supplied file name and path input
Do not echo untrusted input

Proxy Considerations

Publish your metadata over HTTPS to protect your clients from proxy spoofing
If you turn off mutual authentication, be aware of service spoofing

Deployment considerations

Do not use temporary certificates in production
If you are using a custom domain account in the identity pool for your WCF application, create an SPN for Kerberos to authenticate the client.
If you are using a custom service account and need to use trusted for delegation, create an SPN
If you are hosting your service in a Windows Service, using a custom domain identity, and ASP.NET needs to use constrained trusted for delegation when calling the service, create an SPN
Use IIS to host your service unless you need to use a transport that IIS does not support
Use a least privileged account to run your WCF service
Protect sensitive data in your configuration files

HTTP Data Client - An abstract way of web scraping

2011-07-20T13:19:00.000-07:00

Introduction

The purpose of this article is to describe how you can implement a generic “HTTP Data Client” (I apologize if it sounds fussy) using C# which would allow you to query in an elegant manner any web based resources you would like (in one word it allows you to do web scraping). I would like to mention from the beginning that this is not “the perfect solution” and that for sure it can be improved in many ways, so, please feel free to do so. The entire concept it is based on HTTPWebRequest object offered by .NET under System.Net name space.

Prerequisites

Before I’ll start to dwell into architecture and code, there are some extra libraries which are used and required by the “HTTP Data Client” project.

Here is the list of libraries:

Db4Object (this is a object oriented database, I am using it meanly for embedded applications; there are two assembly files which are referenced: Db4objects.Db4o.dll and Db4objects.Db4o.NativeQueries.dll; you can get the DB4Object from the following location: http://www.db4o.com/DownloadNow.aspx)
Html Agility Pack (this is a library which allows you to process HTML content using various techniques, it is very handy when you would like to convert the HTML DOM to XML; there is one assembly file referenced: HtmlAgilityPack.dll; you can get the library from the following location: http://htmlagilitypack.codeplex.com)
Microsoft mshtml (its purpose is to render and parse HTML and JavaScript content)

If you are wondering why I have decided to use two different libraries to parse HTML content, the answer is straight forward. Html Agility Pack is performing really well most of the time; the output you get is usually what you are expecting, but not always. So if one library fails to provide the expected results I can switch to the other one.
The major drawback of MSHTML library in my opinion is the slow processing speed when it is integrated in a non desktop application (e.g.: web sites, web services, etc).

The role of DB4Object in this project is to store configuration settings and cache content. One important thing that has to mentioned about DB4Object is that the non server version doesn’t support multi-threading (you can easily replace with any other storage which is suitable for you).

Architecture

My solution is contains four projects:

HtmlAgilityPack (the actual Html Agility Pack project with source code)
HttpData.Client (main project which implements the rules of HTML processing)
HttpData.Client.MsHtmlToXml (wrapper project over MSHTML and some extensions of it)
HttpData.Client.Pdf (project which implements some PDF processing using IFilter; not important for this article)

There is no point to discuss about HtmlAgilityPack since you can find all details and documentation about it on http://htmlagilitypack.codeplex.com.
I will focus mainly on HttpData.Client and try to offer you as many details and explanations as possible. The http data client is design to work in a similar way with .NET SQL client (System.Data.SqlClient), you will notice that the classes included in project and their logic resembles a lot (I hope is not just my imagination). I will enumerate the interfaces and classes and provide details about their logic and purpose.

IHDPAdapter and HDPAdapter

The purpose of HDPAdapter class is to allow integration of XML data to with other data objects as DataTable and DataSet. The IHDPAdapter interface exposes two methods which convert XML data into either a DataTable or a DataSet. At current time only DataTable conversion method is implemented.
Here is the code snippet for the interface and class:

IHDPAdapter Code

using System.Data;
using System.Xml;

namespace HttpData.Client
{
 /// <summary>
    /// Provides functionality for integration with data objects (DataTable, DataSet, etc). Is implemented by HDPAdapter.
 /// </summary>
 public interface IHDPAdapter
 {
  #region
        /// <summary>
        /// Get or set the select HDPCommand object.
        /// </summary>
        IHDPCommand SelectCommand{ get; set; }
  #endregion

  #region METHODS
        /// <summary>
        /// Fill a data table with the content from a specified xml document object.
        /// </summary>
        /// <param name="table">Data table to be filled.</param>
        /// <param name="source">Xml document object of which content will fill the data table.</param>
        /// <param name="useNodes">True if nodes names should be used for columns names, otherwise attributes will be used.</param>
        /// <returns>Number of filled rows.</returns>
     int Fill(DataTable table, XmlDocument source, bool useNodes);

        /// <summary>
        /// (NOT IMPLEMENTED) Fill a data set with the content from a specified xml document object.
        /// </summary>
        /// <param name="dataset">Data set to be filled.</param>
        /// <param name="source">Xml document object of which content will fill the data table.</param>
        /// <param name="useNodes">True if nodes names should be used for columns names, otherwise attributes will be used.</param>
        /// <returns>Number of filled rows.</returns>
        int Fill(DataSet dataset, XmlDocument source, bool useNodes);
  #endregion
 }
}

HDPAdapter Code

using System;
using System.Xml;
using System.Xml.XPath;
using System.Data;
using System.Text;

namespace HttpData.Client
{
 /// <summary>
 /// Provides functionality for integration with data objects (DataTable, DataSet, etc).
 /// </summary>
 public class HDPAdapter : IHDPAdapter 
 {
  #region PRIVATE VARIABLES
  private IHDPCommand _selectCommand;

     #endregion

  #region Properties
        /// <summary>
        /// Get or set the select IHDPCommand object.
        /// </summary>
  IHDPCommand IHDPAdapter.SelectCommand
  {
   get{ return _selectCommand; }
   set{ _selectCommand = value; }
  }

        /// <summary>
        /// Get or set the select HDPCommand object.
        /// </summary>
  public HDPCommand SelectCommand
  {
   get{ return (HDPCommand)_selectCommand; }
   set{ _selectCommand = value; }
  }

     /// <summary>
     /// Get or set the connection string.
     /// </summary>
     public string ConnectionString { get; set; }

     #endregion

  #region .ctor
        /// <summary>
        /// Create a new instance of HDPAdapter.
        /// </summary>
        public HDPAdapter()
        {
        }

        /// <summary>
        /// Create a new instance of HDPAdapter.
        /// </summary>
        /// <param name="connectionString">Connection string associated with HDPAdapter object.</param>
        public HDPAdapter(string connectionString)
        {
            this.ConnectionString = connectionString;
        }
  #endregion

  #region Public Methods
        /// <summary>
        /// Fill a data table with the content from a specified xml document object.
        /// </summary>
        /// <param name="table">Data table to be filled.</param>
        /// <param name="source">Xml document object of which content will fill the data table.</param>
        /// <param name="useNodes">True if nodes names should be used for columns names, otherwise attributes will be used.</param>
        /// <returns>Number of filled rows.</returns>
        public int Fill(DataTable table, XmlDocument source, bool useNodes)
        {
            bool columnsCreated = false;
            bool resetRow = false;

            if(table == null || source == null)
                return 0;

            if (table.TableName.Length == 0)
                return 0;

            StringBuilder sbExpression = new StringBuilder("//");
            sbExpression.Append(table.TableName);

            XPathNavigator xpNav = source.CreateNavigator();
            if (xpNav != null)
            {
                XPathNodeIterator xniNode = xpNav.Select(sbExpression.ToString());

                while(xniNode.MoveNext())
                {
                    XPathNodeIterator xniRowNode = xniNode.Current.SelectChildren(XPathNodeType.Element);
                    while (xniRowNode.MoveNext())
                    {
                        if(resetRow)
                        {
                            xniRowNode.Current.MoveToFirst();
                            resetRow = false;
                        }

                        DataRow row = null;
                        if (columnsCreated)
                            row = table.NewRow();
                    
                        if(useNodes)
                        {
                            XPathNodeIterator xniColumnNode = xniRowNode.Current.SelectChildren(XPathNodeType.Element);
                            while (xniColumnNode.MoveNext())
                            {
                                if (!columnsCreated)
                                {
                                    DataColumn column = new DataColumn(xniColumnNode.Current.Name);
                                    table.Columns.Add(column);
                                }
                                else
                                    row[xniColumnNode.Current.Name] = xniColumnNode.Current.Value;
                            }
                        }
                        else
                        {
                            XPathNodeIterator xniColumnNode = xniRowNode.Clone();
                            bool onAttribute = xniColumnNode.Current.MoveToFirstAttribute();
                            while (onAttribute)
                            {
                                if (!columnsCreated)
                                {
                                    DataColumn column = new DataColumn(xniColumnNode.Current.Name);
                                    table.Columns.Add(column);
                                }
                                else
                                    row[xniColumnNode.Current.Name] = xniColumnNode.Current.Value;

                                onAttribute = xniColumnNode.Current.MoveToNextAttribute();
                            }
                        }

                        if (!columnsCreated)
                        {
                            columnsCreated = true;
                            resetRow = true;
                        }

                        if (row != null)
                            table.Rows.Add(row);
                    }
                }
            }

            return table.Rows.Count;
        }

        /// <summary>
        /// (NOT IMPLEMENTED) Fill a data set with the content from a specified xml document object.
        /// </summary>
        /// <param name="dataset">Data set to be filled.</param>
        /// <param name="source">Xml document object of which content will fill the data table.</param>
        /// <param name="useNodes">True if nodes names should be used for columns names, otherwise attributes will be used.</param>
        /// <returns>Number of filled rows.</returns>
  public int Fill(DataSet dataset, XmlDocument source, bool useNodes)
  {
            throw new NotImplementedException();
  }
  #endregion

        #region Private Methods
     #endregion
    }
}

IHDPConnection and HDPConnection

As the name says this represents the connection class which will manage in an abstract way how a connection behaves. The interface exposes a set of methods and properties relevant to it.
There are only three methods exposed and implemented:

Open method (changes the connection state to open; this method has an override which accepts as parameter the URL of the web resource which will be opened)
Close method (changes the connection state to close and if there is a cache storage in use it closes it)
CreateCommand method (it creates a new HDPCommand object and assigns the current connection to it)

Now let us take a look at the properties exposed by IHDPConnection and implemented by HDPConnection:

ConnectionURL (represents the web resource URL which will be opened using current connection)
KeepAlive (defines if the connection should be kept opened or not once the querying is done)
AutoRedirect (defines if the connection allows any auto-redirects to be performed)
MaxAutoRedirects (defines how many auto-redirects can be performed)
UserAgent (defines what user agent will be associated with the connection, e.g.: Internet Explorer, Chrome, Opera, etc)
ConnectionState (read only property which provides information about the connection state; is connection opened or closed)
Proxy (defines what proxy will be used when querying is performed)
Cookies (cookies associated with the connection currently or on when the querying takes place)
ContentType (defines what content type is expected when querying takes place, e.g.: application/x-www-form-urlencoded, application/json, etc)
Headers (contains the headers associated with the connection currently or when the querying takes place)
Referer (contains the referrer which is going to be used when querying the connection URL)

IHDPConnection Code

using System.Collections.Generic;
using System.Net;

namespace HttpData.Client
{
 /// <summary>
    /// Provides functionality for connection management of different web sources. Is implemented by HDPConnection.
 /// </summary>
 public interface IHDPConnection
 {
  #region MEMBERS
  #region METHODS
        /// <summary>
        /// Open connection.
        /// </summary>
  void Open();

        /// <summary>
        /// Close connection.
        /// </summary>
  void Close();

        /// <summary>
        /// Create a new HDPCommand object associated with this connection.
        /// </summary>
        /// <returns>HDPCommand object associated with this connection.</returns>
  IHDPCommand CreateCommand();
  #endregion

  #region PROPERTIES
        /// <summary>
        /// Get or set connection url.
        /// </summary>
  string ConnectionURL { get; set; }

        /// <summary>
        /// Get or set the value which specifies if the connection should be maintained openend.
        /// </summary>
        bool KeepAlive { get; set; }

        /// <summary>
        /// Get or set the value which specifies if auto redirection is allowed.
        /// </summary>
        bool AutoRedirect { get; set; }

        /// <summary>
        /// Get or set the value which specifies if maximum number of auto redirections.
        /// </summary>
        int MaxAutoRedirects { get; set; }

        /// <summary>
        /// Get or set the value which specifies the user agent to be used.
        /// </summary>
        string UserAgent { get; set; }

        /// <summary>
        /// Get the value which specifies the state of the connection.
        /// </summary>
  HDPConnectionState ConnectionState { get; }

        /// <summary>
        /// Get or set the value which specifies the connection proxy.
        /// </summary>
        HDPProxy Proxy { get; set; }

        /// <summary>
        /// Get or set the value which specifies the coockies used by connection.
        /// </summary>
        CookieCollection Cookies { get; set; }

        /// <summary>
        /// Get or set the value which specifies the content type.
        /// </summary>
        string ContentType { get; set; }

        /// <summary>
        /// Get or set headers details used in HttpWebRequest operations.
        /// </summary>
        List<HDPConnectionHeader> Headers { get; set; }

        /// <summary>
        /// Get or set Http referer.
        /// </summary>
        string Referer { get; set; }
        #endregion
  #endregion
 }
}

HDPConnection Code

using System.Collections.Generic;
using System.Net;

namespace HttpData.Client
{
    /// <summary>
    /// Provides functionality for connection management of different web sources.
    /// </summary>
    public class HDPConnection : IHDPConnection
    {
        #region Private Variables
        private HDPConnectionState _connectionState;
        private string _connectionURL;
        private HDPCache cache;
        private bool useCache;
        #endregion

        #region Properties
        /// <summary>
        /// Get the value which specifies if caching will be used.
        /// </summary>
        public bool UseCahe
        {
            get { return useCache; }
        }

        /// <summary>
        /// Get HDPCache object.
        /// </summary>
        public HDPCache Cache
        {
            get { return cache; }
        }
        #endregion

        #region .ctor
        /// <summary>
        /// Instantiate a new HDPConnection object.
        /// </summary>
        public HDPConnection()
        {
            _connectionState = HDPConnectionState.Closed;
            _connectionURL = "";
            Cookies = new CookieCollection();
            MaxAutoRedirects = 1;
        }

        /// <summary>
        /// Instantiate a new HDPConnection object.
        /// </summary>
        /// <param name="connectionURL">Url of the web source.</param>
        public HDPConnection(string connectionURL)
        {
            _connectionState = HDPConnectionState.Closed;
            _connectionURL = connectionURL;
            Cookies = new CookieCollection();
            MaxAutoRedirects = 1;
        }

        /// <summary>
        /// Instantiate a new HDPConnection object.
        /// </summary>
        /// <param name="cacheDefinitions">HDPCacheDefinition object used by caching mechanism.</param>
        public HDPConnection(HDPCacheDefinition cacheDefinitions)
        {
            _connectionState = HDPConnectionState.Closed;
            _connectionURL = "";
            Cookies = new CookieCollection();
            MaxAutoRedirects = 1;
            cache = cacheDefinitions != null ? new HDPCache(cacheDefinitions) : null;
            useCache = true;
        }

        /// <summary>
        /// Instantiate a new HDPConnection object.
        /// </summary>
        /// <param name="connectionURL">Url of the web source.</param>
        /// <param name="cacheDefinitions">HDPCacheDefinition object used by caching mechanism.</param>
        public HDPConnection(string connectionURL, HDPCacheDefinition cacheDefinitions)
        {
            _connectionState = HDPConnectionState.Closed;
            _connectionURL = connectionURL;
            Cookies = new CookieCollection();
            MaxAutoRedirects = 1;
            cache = cacheDefinitions != null ? new HDPCache(cacheDefinitions) : null;
            useCache = true;
        }
        #endregion

        #region Public Methods
        #endregion

        #region IHDPConnection Members
        #region Methods
        /// <summary>
        /// Open connection.
        /// </summary>
        public void Open()
        {
            _connectionState = HDPConnectionState.Open;
        }

        /// <summary>
        /// Open connection using a specific url.
        /// </summary>
        /// <param name="connectionURL">Url of the web source.</param>
        public void Open(string connectionURL)
        {
            _connectionURL = connectionURL;
            _connectionState = HDPConnectionState.Open;
        }

        /// <summary>
        /// Close connection.
        /// </summary>
        public void Close()
        {
            _connectionState = HDPConnectionState.Closed;

            if (cache != null)
                cache.CloseStorageConnection();
        }

        /// <summary>
        /// Create a new IHDPCommand object associated with this connection.
        /// </summary>
        /// <returns>IHDPCommand object associated with this connection.</returns>
        IHDPCommand IHDPConnection.CreateCommand()
        {
            HDPCommand command = new HDPCommand { Connection = this };
            return command;
        }

        /// <summary>
        /// Create a new HDPCommand object associated with this connection.
        /// </summary>
        /// <returns>HDPCommand object associated with this connection.</returns>
        public HDPCommand CreateCommand()
        {
            HDPCommand command = new HDPCommand { Connection = this };
            return command;
        }
        #endregion

        #region Properties
        /// <summary>
        /// Get or set connection url.
        /// </summary>
        public string ConnectionURL
        {
            get { return _connectionURL; }
            set { _connectionURL = value; }
        }

        /// <summary>
        /// Get or set the value which specifies if auto redirection is allowed.
        /// </summary>
        public bool AutoRedirect { get; set; }

        /// <summary>
        /// Get or set the value which specifies if maximum number of auto redirections.
        /// </summary>
        public int MaxAutoRedirects { get; set; }

        /// <summary>
        /// Get or set the value which specifies if the connection should be maintained openend.
        /// </summary>
        public bool KeepAlive { get; set; }

        /// <summary>
        /// Get or set the value which specifies the user agent to be used.
        /// </summary>
        public string UserAgent { get; set; }

        /// <summary>
        /// Get or set the value which specifies the content type.
        /// </summary>
        public string ContentType { get; set; }

        /// <summary>
        /// Get or set the value which specifies the coockies used by connection.
        /// </summary>
        public CookieCollection Cookies { get; set; }

        /// <summary>
        /// Get the value which specifies the state of the connection.
        /// </summary>
        public HDPConnectionState ConnectionState
        {
            get { return _connectionState; }
        }

        /// <summary>
        /// Get or set the value which specifies the connection proxy.
        /// </summary>
        public HDPProxy Proxy { get; set; }

        /// <summary>
        /// Get or set headers details used in HttpWebRequest operations.
        /// </summary>
        public List<HDPConnectionHeader> Headers { get; set; }

        /// <summary>
        /// Get or set Http referer.
        /// </summary>
        public string Referer { get; set; }
        #endregion
        #endregion

        #region IDisposable Members
        ///<summary>
        /// Dispose current object.
        ///</summary>
        public void Dispose()
        {
            this.dispose();
            System.GC.SuppressFinalize(this);
        }

        private void dispose()
        {
            if (_connectionState == HDPConnectionState.Open)
                this.Close();
        }
        #endregion
    }
}

IHDPCommand and HDPCommand

This represents our engine which provides functionality for querying web resources and processing the result (response). It offers a variety of way that can be used to process the response content of the query as: XPath, RegEx, XSLT, reflection, etc. I will discuss in detail only the main methods, rest of them are leveraged on those and I assume the comments which accompany the methods are suffice to provide guidance in the right direction. But before I’ll reach the methods, let me present you the properties.

Connection (defines the connection object associated with this command)
Parameters (defines the parameters used in the querying process)
CommandType (defines the command type used in querying process; it is either GET either POST)
CommandText (defines the content of the command which is going to executed; if this is a GET command then the URL with query parameters are stored, if it is a POST command, then the body content of the post action is stored)
CommandTimeout (defines the time period in which a response is expected from the web resource)
Response (contains the response string received from the web resource based on a query action)
Uri (contains the URI of the queried web resource)
Path (contains the path of the web resource queried)
LastError (contains the last error message encountered in the process)
ContentLength (contains the length of the content received from the web resource based on a query action)

We can move now to the exposed/implemented methods.

GetParametersCount (gets the number of parameters used in the query process)
CreateParameter (create a new parameter to be used in the query process)
ExecuteNonQuery (executes a query on a web resources using either GET or POST methods and it returns the number of results received. It has one parameter which specifies if the collection of parameters used in the query process should be cleaned at the end)
Execute(executes a query on a web resources using either GET or POST methods and it returns a Boolean value, true if the query was executed with success, false if it failed)
ExecuteStream (executes a query on a web resources using either GET or POST methods and it returns the underlying http response stream)
CloseResponse (it closes the http response stream opened by ExecuteStream method)
ExecuteNavigator (executes a query on a web resources using either GET or POST methods and it returns a XPathNavigator object used to navigate thru the response converted to XML. It has one parameter which specifies if the collection of parameters used in the query process should be cleaned at the end)
ExecuteDocument (it has an override, executes a query on a web resources using either GET or POST methods and it returns a IXPathNavigable object used to navigate thru the response converted to XML, the “expression” parameter represents a XPath expression which will be used in the processing of the result)
ExecuteBinary (executes a query on a web resources using either GET or POST methods and it returns a result in byte array format. This is mostly used when querying binary content from web resources e.g.: PDF files, images. One of the overridden method parameters imposes a limit on the output buffer)
ExecuteBinaryConversion (executes a query on a web resources using either GET or POST methods and it returns a result as string. This is used when querying binary content from web resources e.g.: PDF files and the content of a PDF file is converted from binary to string)
ExecuteString (executes a query on a web resources using either GET or POST methods and it returns a result as plain string)
ExecuteValue (executes a query on a web resource using either GET or POST methods and it returns a result as string which is a representation of an XPath expression applied. Instead of an XPath expression it can be an RegEx)
ExecuteCollection (executes a query on a web resource using either GET or POST methods and it returns a result as generic string collection. The result is a representation of an either XPath or RegEx expression applied on the result)
ExecuteArray (executes a query on a web resource using either GET or POST methods and it returns a result as a string array. The result is a representation of an either XPath or RegEx expression applied on the result)

IHDPCommand Code

using System.Collections.Generic;
using System.IO;
using System.Xml.XPath;

namespace HttpData.Client
{
    /// <summary>
    /// Provides functionality for querying and processing data from different web sources. Is implemented by HDPCommand.
    /// </summary>
    public interface IHDPCommand
    {
        #region Members
        #region Properties
        /// <summary>
        /// Get or set the command connection object.
        /// </summary>
        IHDPConnection Connection { get; set; }

        /// <summary>
        /// Get or set the command parameters collection.
        /// </summary>
        IHDPParameterCollection Parameters { get; }

        /// <summary>
        /// Get or set the command type.
        /// </summary>
        HDPCommandType CommandType { get; set; }

        /// <summary>
        /// Get or set the command text. 
        /// </summary>
        string CommandText { get; set; }

        /// <summary>
        /// Get or set the command timeout.
        /// </summary>
        int CommandTimeout { get; set; }

        /// <summary>
        /// Get the response retrieved from the server.
        /// </summary>
        string Response { get; }

        /// <summary>
        /// Get web resource URI.
        /// </summary>
        string Uri { get; }

        /// <summary>
        /// Get web resource absolute path.
        /// </summary>
        string Path { get; }

        /// <summary>
        /// Get the last error occurend.
        /// </summary>
        string LastError { get; }

        /// <summary>
        /// Get the content length of response.
        /// </summary>
        long ContentLength { get; }
        #endregion

        #region Methods
        /// <summary>
        /// Get the parameters number.
        /// </summary>
        /// <returns>Number of parameters.</returns>
        int GetParametersCount();

        /// <summary>
        /// Create a new IHDPParameter object.
        /// </summary>
        /// <returns>IHDPParameter parameter object.</returns>
        IHDPParameter CreateParameter();

        /// <summary>
        /// Execute a expression against the web server and return the number of results.
        /// </summary>
        /// <param name="clearParams">Specify if the parameters collection should be cleared after the query is executed.</param>
        /// <returns>Number of results determined by the expression.</returns>
        int ExecuteNonQuery(bool clearParams);

        /// <summary>
        /// Execute a query against the web server and does not read the response stream.
        /// </summary>
        /// <returns>True is the command executed with success otherwise false.</returns>
        bool Execute();

        /// <summary>
        /// Execute a query against the web server.
        /// </summary>
        /// <param name="clearParams">Specify if the parameters collection should be cleared after the query is executed.</param>
        /// <returns>True is the command executed with success otherwise false.</returns>
        bool Execute(bool clearParams);

        /// <summary>
        /// Execute a query against the web server.
        /// </summary>
        /// <param name="clearParams">Specify if the parameters collection should be cleared after the query is executed.</param>
        /// <returns>Returns the underlying http response stream.</returns>
        Stream ExecuteStream(bool clearParams);

        /// <summary>
        /// Closes the http response object..
        /// Usable only with ExecuteStream method.  
        /// </summary>
        void CloseResponse();

        /// <summary>
        /// Execute a query against the web server and return a XPathNavigator object used to navigate thru the query result.
        /// </summary>
        /// <param name="clearParams">Specify if the parameters collection should be cleared after the query is executed.</param>
        /// <returns>XPathNavigator object used to navigate thru the query result.</returns>
        XPathNavigator ExecuteNavigator(bool clearParams);

        /// <summary>
        /// Execute a query against the web server and return a IXPathNavigable object used to navigate thru the query result.
        /// </summary>
        /// <param name="clearParams">Specify if the parameters collection should be cleared after the query is executed.</param>
        /// <returns>IXPathNavigable object used to navigate thru the query result.</returns>
        IXPathNavigable ExecuteDocument(bool clearParams);

        /// <summary>
        /// Execute a query against the web server, on query reult it will apply a xpath expression and return a IXPathNavigable object used to navigate thru query result.
        /// </summary>
        /// <param name="expression">XPath expression.</param>
        /// <param name="clearParams">Specify if the parameters collection should be cleared after the query is executed.</param>
        /// <returns>IXPathNavigable object used to navigate thru query result.</returns>
        IXPathNavigable ExecuteDocument(string expression, bool clearParams);

        /// <summary>
        /// Execute a query against the web server and return a byte[] object which contains the binary query result. Used when querying binary content from web server (E.g: PDF files).
        /// </summary>
        /// <param name="clearParams">Specify if the parameters collection should be cleared after the query is executed.</param>
        /// <returns>Byte array object which contains the binary query result.</returns>
        byte[] ExecuteBinary(bool clearParams);

        /// <summary>
        /// Execute a query against the web server and return a byte[] object which contains the binary query result. Used when querying binary content from web server (E.g: PDF files).
        /// </summary>
        /// <param name="boundaryLimit">Specify the limit of the buffer which must be read.</param>
        /// <param name="clearParams">Specify if the parameters collection should be cleared after the query is executed.</param>
        /// <returns>Byte array object which contains the binary query result.</returns>
        byte[] ExecuteBinary(int boundaryLimit, bool clearParams);

        /// <summary>
        ///  Execute a query against the web server and return a string object which contains the representation of the binary query result. Used when querying binary content from web server (E.g: PDF files).
        /// </summary>
        /// <param name="clearParams">Specify if the parameters collection should be cleared after the query is executed.</param>
        /// <returns>String object which contains the representation of the binary query result.</returns>
        string ExecuteBinaryConversion(bool clearParams);

        /// <summary>
        /// Execute a query against the web server and return a string object which contains the representation of the query result.
        /// </summary>
        /// <param name="clearParams">Specify if the parameters collection should be cleared after the query is executed.</param>
        /// <returns>String object which contains the representation of the query result.</returns>
        string ExecuteString(bool clearParams);

        /// <summary>
        /// Execute a query against the web server, on query reult it will apply a xpath expression and return a string object which contains the representation of the query result value.
        /// </summary>
        /// <param name="expression">XPath expression.</param>
        /// <param name="clearParams">Specify if the parameters collection should be cleared after the query is executed.</param>
        /// <returns>String object which contains the representation of the query result value.</returns>
        string ExecuteValue(string expression, bool clearParams);

        /// <summary>
        /// Execute a query against the web server, on query reult it will apply a regular expression and return a string object which contains the representation of the query result value.
        /// </summary>
        /// <param name="expression">Regular expression.</param>
        /// <param name="clearParams">Specify if the parameters collection should be cleared after the query is executed.</param>
        /// <param name="isRegEx">Specify the a regular expression is used, it must always be to true.</param>
        /// <returns>String object which contains the representation of the query result value.</returns>
        string ExecuteValue(string expression, bool clearParams, bool isRegEx);

        /// <summary>
        /// Execute a query against the web server, on query reult it will apply a regular expression and return a List object which contains the representation of the query result.
        /// </summary>
        /// <param name="expression">Regular expression.</param>
        /// <param name="clearParams">Specify if the parameters collection should be cleared after the query is executed.</param>
        /// <param name="isRegEx">Specify the a regular expression is used, it must always be to true.</param>
        /// <returns>List object which contains the representation of the query result.</returns>
        List<string> ExecuteCollection(string expression, bool clearParams, bool isRegEx);

        /// <summary>
        /// Execute a query against the web server, on query reult it will apply a xpath expression and return a List object which contains the representation of the query result.
        /// </summary>
        /// <param name="expression">XPath expression.</param>
        /// <param name="clearParams">Specify if the parameters collection should be cleared after the query is executed.</param>
        /// <returns>List object which contains the representation of the query result.</returns>
        List<string> ExecuteCollection(string expression, bool clearParams);

        /// <summary>
        /// Execute a query against the web server, on query reult it will apply a regular expression and return a string array object which contains the representation of the query result.
        /// </summary>
        /// <param name="expression">Regular expression.</param>
        /// <param name="clearParams">Specify if the parameters collection should be cleared after the query is executed.</param>
        /// <param name="isRegEx">Specify the a regular expression is used, it must always be to true.</param>
        /// <returns>String array object which contains the representation of the query result.</returns>
        string[] ExecuteArray(string expression, bool clearParams, bool isRegEx);

        /// <summary>
        /// Execute a query against the web server, on query reult it will apply a xpath expression and return a string array object which contains the representation of the query result.
        /// </summary>
        /// <param name="expression">XPath expression.</param>
        /// <param name="clearParams">Specify if the parameters collection should be cleared after the query is executed.</param>
        /// <returns>String array object which contains the representation of the query result.</returns>
        string[] ExecuteArray(string expression, bool clearParams);
        #endregion
        #endregion
    }
}

HDPCache, HDPCacheDefinition, HDPCacheObject and HDPCacheStorage

HDPCache, HDPCacheDefinition, HDPCacheObject and HDPCacheStorage are the classes which handle the cache. I will not insist on this subject since is not so important in this case. If you like you can study those classes in more detail by yourself. I think the code comments will help you to grasp they purpose and functionality quite fast.

The class HDPCacheObject is straight forward; it contains a set of properties which define the cache behavior. Here are its properties:

StorageActiveUntil (defines the date until the cache is considered to be valid)
MemorySizeLimit (imposes a memory size limit of the cache)
ObjectsNumberLimit (imposes a objects number limit on the cache)
UseStorage (defines if the cache should be persisted on disk)
RetrieveFromStorage (defines if a specific value should be searched on the persisted cache on disk)
RealtimePersistance (defines if the cache will be persisted on disk in real time, once a new value has been added to it)
StorageName (defines the file name of the posited cache on disk)

The class HDPCacheObject is just a value pair set of properties and a time stamp field used to identify the cached object age. The caching system works in a very clear and simple manner. When a web resource is queried the URL of it represents the cache object key and the result of the query represents the cache object value. If the cache is activated when using HDPCommand object to query web resources each query URL and response content are stored in the memory cache. If same web resource is queried again using same URL the HTTP request is not performed and response content is retrieved from the memory cache. There are extra options defined in HDPCacheDefinition which allow you to control how the cache behaves. For example if you impose a cache memory limit of 1024Kb then every time a new value is added to the cache its memory footprint is calculated. In case the imposed limit is exceeded, based on other behavior definitions the cache content is either stored on disk or either deleted. I would like to mention that MemorySizeLimit and ObjectsNumberLimit are mutual exclusive. So if you define a value for the MemorySizeLimit greater than 0 then there is no point to define a value for ObjectsNumberLimit because it will not be taken into consideration and vice versa.

HDPCacheDefinition Code

using System;

namespace HttpData.Client
{
    ///<summary>
    /// Defines the cache options.
    ///</summary>
    public class HDPCacheDefinition
    {
        #region Public Variables
        /// <summary>
        /// Specifies the date until which the cache is valid.
        /// </summary>
        public DateTime StorageActiveUntil = DateTime.Now.AddDays(1);

        /// <summary>
        /// Specifies the limit size of the cache memory.
        /// </summary>
        public long MemorySizeLimit;

        /// <summary>
        /// Specifies the limit number of objects which can be stored in the cache.
        /// </summary>
        public int ObjectsNumberLimit = 10000;

        /// <summary>
        /// Specifies if disk storage will be used.
        /// </summary>
        public bool UseStorage = true;
        
        ///<summary>
        /// Specifies if the data should be retrieved from the disk storage.
        ///</summary>
        public bool RetrieveFromStorage;

        /// <summary>
        /// Specifies if the persistance of the cache on disk will be done in real time.
        /// </summary>
        public bool RealtimePersistance;
        
        /// <summary>
        /// Specifies the name of the file of the disk storage.
        /// </summary>
        public string StorageName = "HttpDataProcessorCahe.che";
        #endregion
    }
}

HDPCacheObject Code

using System;

namespace HttpData.Client
{
    /// <summary>
    /// Container for the cached data based on key value pair.
    /// </summary>
    [Serializable]
    public class HDPCacheObject
    {
        #region Private Variables
        private string key;
        private object value;
        private DateTime cacheDate;
        #endregion

        #region Properties
        /// <summary>
        /// Get or set the cache object key.
        /// </summary>
        public string Key
        {
            get { return key; }
            set { key = value; }
        }

        /// <summary>
        /// Get or set the cache object value.
        /// </summary>
        public object Value
        {
            get { return value; }
            set { this.value = value; }
        }

        /// <summary>
        /// Get or set the cache object date.
        /// </summary>
        public DateTime CacheDate
        {
            get { return cacheDate; }
        }
        #endregion

        #region .ctor
        /// <summary>
        /// Instantiate a new HDPCacheObject object.
        /// </summary>
        public HDPCacheObject()
        {
            cacheDate = DateTime.Now;
        }

        /// <summary>
        /// Instantiate a new HDPCacheObject object.
        /// </summary>
        /// <param name="key">Key for the cache object</param>
        /// <param name="value">Value for the cache object</param>
        public HDPCacheObject(string key, object value)
        {
            this.key = key;
            this.value = value;

            cacheDate = DateTime.Now;
        }
        #endregion

        #region Public Methods
        #endregion

        #region Private Methods
        #endregion
    }
}

Using the code

I will provide a couple of examples so you can figure it out how things work. I consider this to be the best way to understand how the earth spins.
Let us say for example that we would like to retrieve all Florida cities from the following page: http://www.stateofflorida.com/Portal/DesktopDefault.aspx?tabid=34.
Here is the code to achieve the above mentioned task.

using System;
using System.Collections.Generic;
using HttpData.Client;

namespace CityStates
{
    class Program
    {
        static void Main(string[] args)
        {
            private const string connectionUrl = "http://www.stateofflorida.com/Portal/DesktopDefault.aspx?tabid=34";

     //Create a new instance of HDPCacheDefinition object.
            HDPCacheDefinition cacheDefinition = new HDPCacheDefinition
            {
                UseStorage = false,
                StorageActiveUntil = DateTime.Now,
                ObjectsNumberLimit = 10000,
                RealtimePersistance = false,
                RetrieveFromStorage = false,
         //We will not use a disk storage
                StorageName = null
            };

            //Create a new instance of HDPConnection object.
            //Pass as parameters the initial connection URL and the cache definition object.
            HDPConnection connection = new HDPConnection(connectionUrl, cacheDefinition)
            {
                //Define the content type we would expect.
                ContentType = HDPContentType.TEXT,
                //We want to allow autoredirects
                AutoRedirect = true,
                //Do not perform more than 10 autoredirects
                MaxAutoRedirects = 10,
                //The user agent is FireFox 3
                UserAgent = HDPAgents.FIREFOX_3,
                //We do not want to use a proxy
                Proxy = null // If you want to use a proxy: Proxy = new HDPProxy("http://127.0.0.1:999/"/*This is your proxy address and its port*/, "PROXY_USER_NAME", "PROXY_PASSWORD")
            };
            //Open the connection
            connection.Open();

            //Create a new instance of HDPCommand object.
            //Pass as parameter the HDPConnection object.
            HDPCommand command = new HDPCommand(connection)
            {
                //Activate the memory cache for fast access on same  web resource multiple times
                ActivatePool = true,
                //We will perform an GET action
                CommandType = HDPCommandType.Get,
                //Set the time out period
                CommandTimeout = 60000,
                //Use MSHTML library instead of HtmlAgilityPack (if the value is false then HtmlAgilityPack would be used)
                UseMsHtml = true
            };

            //Execute the query on the web resource. The received HTTPWebResponse content will be converted to XML and the XPath expression will be executed.
            //The method will return the list of Florida state cities.
            List cities = command.ExecuteCollection("//ul/li/b//text()[normalize-space()]", true);
   
     foreach (string city in cities)
         Console.WriteLine(city);
   
     connection.Close();
        }
    }
}

Here is a different example now. Let us say that we would like to login on Linkedin network using an account user name and password. Here is the code to achieve that.

using System;
using System.Collections.Generic;
using HttpData.Client;

namespace CityStates
{
    class Program
    {
        static void Main(string[] args)
        {
            private const string connectionUrl = "https://www.linkedin.com/secure/login?trk=hb_signin";

     //Create a new instance of HDPCacheDefinition object.
            HDPCacheDefinition cacheDefinition = new HDPCacheDefinition
            {
                UseStorage = false,
                StorageActiveUntil = DateTime.Now,
                ObjectsNumberLimit = 10000,
                RealtimePersistance = false,
                RetrieveFromStorage = false,
         //We will not use a disk storage
                StorageName = null
            };

            //Create a new instance of HDPConnection object.
            //Pass as parameters the initial connection URL and the cache definition object.
            HDPConnection connection = new HDPConnection(connectionUrl, cacheDefinition)
            {
                //Define the content type we would expect.
                ContentType = HDPContentType.TEXT,
                //We want to allow autoredirects
                AutoRedirect = true,
                //Do not perform more than 10 autoredirects
                MaxAutoRedirects = 10,
                //The user agent is FireFox 3
                UserAgent = HDPAgents.FIREFOX_3,
                //We do not want to use a proxy
                Proxy = null // If you want to use a proxy: Proxy = new HDPProxy("http://127.0.0.1:999/"/*This is your proxy address and its port*/, "PROXY_USER_NAME", "PROXY_PASSWORD")
            };
            //Open the connection
            connection.Open();

            //Create a new instance of HDPCommand object.
            //Pass as parameter the HDPConnection object.
            HDPCommand command = new HDPCommand(connection)
            {
                //Activate the memory cache for fast access on same  web resource multiple times
                ActivatePool = true,
                //We will perform an GET action
                CommandType = HDPCommandType.Get,
                //Set the time out period
                CommandTimeout = 60000,
                //Use HtmlAgilityPack (if the value is true then MSHTML would be used)
                UseMsHtml = false
            };

            //Define the query parameters used in the POST action.
            //The actual parameter name used by a browser to authenticate you on Linkedin is without '@' sign.
            //Use a HTTP request analyzer and you will notice the difference.
            //This is how the actual POST body will look like: csrfToken="ajax:-3801133150663455891"&session_key="YOUR_EMAIL@gmail.com"&session_password="YOUR_PASSWORD"&session_login="Sign+In"&session_login=""&session_rikey=""
            HDPParameterCollection parameters = new HDPParameterCollection();
            HDPParameter pToken = new HDPParameter("@csrfToken", "ajax:-3801133150663455891");
            HDPParameter pSessionKey = new HDPParameter("@session_key", "YOUR_EMAIL@gmail.com");
            HDPParameter pSessionPass = new HDPParameter("@session_password", "YOUR_PASSWORD");
            HDPParameter pSessionLogin = new HDPParameter("@session_login", "Sign+In");
            HDPParameter pSessionLogin_ = new HDPParameter("@session_login", "");
            HDPParameter pSessionRiKey = new HDPParameter("@session_rikey", "");

            parameters.Add(pToken);
            parameters.Add(pSessionKey);
            parameters.Add(pSessionPass);
            parameters.Add(pSessionLogin);
            parameters.Add(pSessionLogin_);
            parameters.Add(pSessionRiKey);

     //If everything went ok then linkeding will ask us to redirect (unfortunately autoredirect doesn't work in this case).
            //Get the manual redirect URL value. 
     string value = command.ExecuteValue("//a[@id='manual_redirect_link']/@href", true);
            if (value != null && String.Compare(value, "http://www.linkedin.com/home") == 0)
            {
                command.Connection.ConnectionURL = value;
                command.CommandType = HDPCommandType.Get;

    //Using the manual redirect URL, check if the opened web page contains the welcome message.
                //If it does contain the message, then we are in.
                string content = command.ExecuteString("//title[contains(.,'Welcome,')]", true);

                if (content.Length > 0)
                    Console.WriteLine(content);
    else
     Console.WriteLine("Login failed!");
            }
   
   connection.Close();
        }
    }
}

On your sample project please add the following app.config content if you are going to use MSHTML.


<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <appSettings>
    <add key="LogFilePath" value="..\Log\My-Log.txt"/>
    <add key="HtmlTagsPath" value="HtmlTags.txt"/>
    <add key="AttributesTagsPath" value="HtmlAttributes.txt"/>
  </appSettings>
</configuration>

Downloads and Source Code

You can download the source code of the library and a sample project from here

ASP.NET/IIS7 Custom HTTP Handlers

2011-05-23T06:13:00.000-07:00

It's been a while since I had to write custom HTTP handlers. One of my current projects required resourses to be provided using a custom HTTP handler. That was quite an easy job and for sure you will find many detailed posts related to HTTP handlers development under .NET. The only thing which gave me some headaches was the deployment of such a handler. There is a different approach under IIS7 (integrated mode) compared with IIS6. Here are the required steps:

1. From IIS management interface create a web application which points to the root folder where you have your HTTP handler. Please note that the actual DLL (assembly) should be located under root directory in a "bin" folder (e.g.: C:\MyHandlerRootFolder\bin\myhandler.dll). Please be sure that you are configuring your web application to run under the correct application pool. So if your HTTP handler assembly is compiled with .NET 4.0 be sure that the web application is configured to run under ASP.NET v4.0 application pool. My issue was caused by a missconfiguration of the HTTP handler. Due to this, everyt time when I was trying to access the handler I was getting the following exception: "Could not load type 'MyHandlerClass'"

2. In the web.config file which should be hosted in your web application root folder add (or change if it is the case) the following configuration elements:

<system.webServer>
    <handlers>
      <add verb="*" path="*.myextension"
        name="MyHttpHandler"
        type=" MyFullNamespace.MyHandlerClass, MyFullHttpHandlerAssemblyName"/>
    </handlers>
  </system.webServer>

That's all, now you handler should be up and running.

Get Table Structure Description

2010-09-09T08:55:00.000-07:00

Use the following script to get the structure description of a specific table:


SELECT
clmns.name AS [Name],
usrt.name AS [DataType],
ISNULL(baset.name, N'') AS [SystemType],
CAST(CASE WHEN baset.name IN (N'nchar', N'nvarchar') AND clmns.max_length <> -1 THEN clmns.max_length/2 ELSE clmns.max_length END AS int) AS [Length],
CAST(clmns.precision AS int) AS [NumericPrecision]
FROM sys.tables AS tbl
INNER JOIN sys.all_columns AS clmns ON clmns.object_id = tbl.object_id
LEFT OUTER JOIN sys.types AS usrt ON usrt.user_type_id = clmns.user_type_id
LEFT OUTER JOIN sys.types AS baset ON baset.user_type_id = clmns.system_type_id and 
baset.user_type_id = baset.system_type_id
WHERE tbl.name='YOURTABLENAME' and SCHEMA_NAME(tbl.schema_id)=N'dbo'
ORDER BY clmns.column_id ASC

The source of the script is: www.geekzilla.co.uk

Monster Website and XSS

2010-07-09T00:35:00.000-07:00

Note:All websites owners where informed more than a week ago about the vulnerabilities I have "accidentally" found.
The purpose of this information is educational only!

In the last week I was playing with some websites trying to find out if they are exposed to any XSS attacks.
Among those websites was also www.monster.com. I know that in the past years Monster had big issues regarding security. They were hacked three times and a huge amount of data was stolen back then. Well...what I have discovered is that they still have vulnerabilities, specially XSS ones. Their filtering system has flaws, considering that it will remove with success <script>, <object>, <iframe> tags but it fails on removing <img>, <html>, <body> and <?import>.
Based on the above mentioned things I created a "Job Seeker" account with a fake CV and in the content of that CV I have inserted the following script:

<HTML><BODY><?xml:namespace prefix='t' ns='urn:schemas-microsoft-com:time'><?import namespace='t' implementation='#default#time2'><t:set attributeName='innerHTML' to='XSS&lt;script DEFER&gt;(function(){alert("Here you can do very nasty things!")})()&lt;/script&gt;'></BODY></HTML>

When I previewed the CV...voila, the alert dialog appeared. In this way I was able to hijack the user session by making use of cookies and extract any information I wanted. The most interesting thing is that in this way some one can hijack the session of any "Employer" which is going to take a look at the CV and with custom "POST" and "GET" commands, infest the job posts of the "Employer" with similar malicious code. In this way a real web could be created starting just from one malicious CV.

There are also issues on Monster website in the section which allows you to upload your CV. You have the option to upload text files and Microsoft Word documents. In a text file I have inserted and <img> tag with an 'onload' event. When the content was rendered on the page and the invisible image was loaded and the 'onload' event was triggered I was able to execute any JavaScript code.

IIS - The worker process failed to preload .Net Runtime version

2009-12-17T10:55:00.000-08:00

When I moved to windows 7 (clean install) I have done a mistake regarding the order in which I have set up the development environment. First, by mistake, I have installed Visual Studio 2008, .NET framework 3.5 and at the end .NET framework 2.0.*. This caused a big issue on IIS 7. Every virtual directory or application created on IIS caused an error on the application pool. I have tried different application pools but got same error: “The worker process failed to preload .Net Runtime version v2.0.40607” and “The worker process failed to initialize correctly and therefore could not be started. The data is the error.”. After some searched over the internet I have found a solution HERE. The fix consists in removing from Windows\Microsoft.Net\Framework of any folder like v2.0.* which is different than v2.0.50727.

JavaScript ArrayList, JavaScript Dictionay, JavaScript Strong Type Array

2009-12-14T01:41:00.000-08:00

I always felt the need to have in JavaScript a more robust set of collections, like those from .NET: ArrayList, Dictionary, strong typed collections. So, some time ago I have decided to implement them everything having as base the JavaScript array object. The code I assume is self explanatory except the class definition which makes use of the custom pattern presented earlier on this blog. It shouldn’t matter too much because it’s very easy for you to implement same functionality using any desired inheritance pattern, like Base2 and Prototype. I think it’s a matter of copy/paste in most cases. You will notice that I didn’t use any special tricks in the code, just the well known JavaScript array object methods and properties. I did not use closures in this case so the ‘_array ‘ property it is consider private base on ‘_’ notation. Using closures eats up more resources so I preferred to avoid them in his case. If you have any questions feel free to post them and I’ll try to give you an answer as fast as possible. You can download the source from HERE.

if (typeof (MG) == 'undefined')
    throw ("MG.Core.js is required!");
if (typeof (MG.Collections) == 'undefined')
    MG.Collections = {};

MG.Collections.IComparer = function() {
    throw ("IComparer is an interface. Interfaces can't be instantiated directly!");
};
MG.Collections.IComparer.prototype = {
    Compare: function(object1, object2) { }
}

/******************************************************************************/
// IList interface definition.
/******************************************************************************/
MG.Collections.IList = function() {
    throw ("IList is an interface. Interfaces can't be instantiated directly!");
};
MG.Collections.IList.prototype = {
    ___name: "IList",
    Add: function(object) { },
    Clear: function() { },
    Contains: function(object) { },
    Remove: function(object) { },
    IsReadOnly: Boolean,
    Item: function(index) { }
};

/******************************************************************************/
// ICollection interface definition.
/******************************************************************************/
MG.Collections.ICollection = function() {
    throw ("ICollection is an interface. Interfaces can't be instantiated directly!");
};
MG.Collections.ICollection.prototype = {
    ___name: "ICollection",
    CopyTo: function(array, arrayIndex) { },
    Count: function() { }
};

/******************************************************************************/
// IDictionary interface definition.
/******************************************************************************/
MG.Collections.IDictionary = function() {
    throw ("IDictionary is an interface. Interfaces can't be instantiated directly!");
};
MG.Collections.IDictionary.prototype = {
    ___name: "IDictionary",
    Add: function(key, value) { },
    Clear: function() { },
    Contains: function(key) { },
    Remove: function(key) { },
    IsReadOnly: Boolean,
    Item: function(key) { }
}

/******************************************************************************/
// ArrayList class definition.
// Implements interfaces: ICollection
/******************************************************************************/

MG.Collections.ArrayList = MG.Class.Create(
                {
                    _array: null,
                    IsReadOnly: Boolean,

                    constructor: function() {
                        this._array = [];
                        this.IsReadOnly = false;
                    },

                    Add: function(object) {
                        if (!this.IsReadOnly)
                            this._array.push(object);
                        else
                            throw ("ArrayList is read only! Check IsReadOnly value.");
                    },

                    Clear: function() {
                        if (!this.IsReadOnly)
                            this._array = [];
                        else
                            throw ("ArrayList is read only! Check IsReadOnly value.");
                    },

                    Contains: function(object) {
                        for (var index = 0; index < this._array.length; index++) {
                            if (this._array[index] == object)
                                return true;
                        }
                        return false;
                    },

                    CopyTo: function(array, arrayIndex) {
                        if (!array)
                            throw ("Destination array is null!");
                        if (arrayIndex < 0 || arrayIndex > array.length)
                            throw ("Index of destination array out of bound! Index value is: " + arrayIndex);

                        for (var i = this._array.length - 1; i >= 0; i--)
                            array.splice(arrayIndex, 0, this._array[i]);
                    },

                    Remove: function(object) {
                        if (!this.IsReadOnly) {
                            for (var index = 0; index < this._array.length; index++) {
                                if (this._array[index] == object)
                                    this._array.splice(index, 1);
                            }
                        }
                        else
                            throw ("ArrayList is read only! Check IsReadOnly value.");
                    },

                    Count: function() {
                        return this._array.length;
                    },

                    Item: function(index) {
                        if (index < 0 || index >= this._array.length)
                            throw ("Index out of bound! Index value is: " + index);

                        return this._array[index];
                    },

                    IndexOf: function(object) {
                        for (var index = 0; index < this._array.length; index++) {
                            if (this._array[index] == object)
                                return index;
                        }
                        return -1;
                    },

                    LastIndexOf: function(object) {
                        var lastIndex = -1;
                        for (var index = 0; index < this._array.length; index++) {
                            if (this._array[index] == object)
                                lastIndex = index;
                        }
                        return lastIndex;
                    },

                    RemoveAt: function(index) {
                        if (!this.IsReadOnly) {
                            if (index < 0 || index >= this._array.length)
                                throw ("Index out of bound! Index value is: " + index);

                            this._array.splice(index, 1);
                        }
                        else
                            throw ("ArrayList is read only! Check IsReadOnly value.");
                    },

                    RemoveRange: function(index, Count) {
                        if (!this.IsReadOnly) {
                            if (index < 0 || index >= this._array.length)
                                throw ("Index out of bound! Index value is: " + index);
                            if (Count < 0 || (Count + index) > this._array.length)
                                throw ("Range out of bound! Range value is: " + Count);

                            this._array.splice(index, Count);
                        }
                        else
                            throw ("ArrayList is read only! Check IsReadOnly value.");
                    },

                    InsertAt: function(index, object) {
                        if (!this.IsReadOnly) {
                            if (index < 0 || index >= this._array.length)
                                throw ("Index out of bound! Index value is: " + index);

                            this._array.splice(index, 0, object);
                        }
                        else
                            throw ("ArrayList is read only! Check IsReadOnly value.");
                    },

                    InsertRange: function(index, _ICollection) {
                        if (!this.IsReadOnly) {
                            if (index < 0 || index >= this._array.length)
                                throw ("Index out of bound! Index value is: " + index);

                            var _newarray = _ICollection.GetRange(0, _ICollection.Count());

                            for (var i = 0; i < _newarray.length; i++)
                                this.InsertAt(index, _newarray[i]);
                        }
                        else
                            throw ("ArrayList is read only! Check IsReadOnly value.");
                    },

                    GetRange: function(index, Count) {
                        if (index < 0 || index >= this._array.length)
                            throw ("Index out of bound! Index value is: " + index);
                        if (Count < 0 || (Count + index) > this._array.length)
                            throw ("Range out of bound! Range value is: " + Count);

                        var arrayList = new ArrayList();
                        arrayList._array = this._array.slice(index, (Count + index));
                        return arrayList;
                    },

                    Reverse: function() {
                        if (!this.IsReadOnly)
                            this._array.reverse();
                        else
                            throw ("ArrayList is read only! Check IsReadOnly value.");
                    },

                    Sort: function() {
                        this._array.sort();
                    }
                }, null, [MG.Collections.ICollection]);

/******************************************************************************/
// DictionaryEntry class definition.
/******************************************************************************/
MG.Collections.DictionaryEntry = MG.Class.Create(
                    {
                        key: null,
                        value: null,
                        constructor: function(key, value) {
                            this.key = key;
                            this.value = value;
                        }
                    });

/******************************************************************************/
// Dictionary class definition.
// Implements interfaces: IDictionary
//                        ICollection
/******************************************************************************/
                    MG.Collections.Dictionary = MG.Class.Create(
                {
                    _dictionary: null,
                    IsReadOnly: Boolean,

                    constructor: function() {
                        this._dictionary = [];
                        this.IsReadOnly = false;
                    },

                    Add: function(key, value) {
                        if (!this.IsReadOnly) {
                            if (this.Contains(key))
                                throw ("Dictionary does not allow duplicate keys!");

                            var dicEntry = new MG.Collections.DictionaryEntry(key, value);
                            this._dictionary.push(dicEntry);
                        }
                        else
                            throw ("Dictionary is read only! Check IsReadOnly value.");
                    },

                    Clear: function() {
                        if (!this.IsReadOnly)
                            this._dictionary = [];
                        else
                            throw ("Dictionary is read only! Check IsReadOnly value.");
                    },

                    Contains: function(key) {
                        for (var index = 0; index < this._dictionary.length; index++) {
                            if (this._dictionary[index].key == key)
                                return true;
                        }
                        return false;
                    },

                    Remove: function(key) {
                        if (!this.IsReadOnly) {
                            for (var index = 0; index < this._dictionary.length; index++) {
                                if (this._dictionary[index].key == key)
                                    this._dictionary.splice(index, 1);
                            }
                        }
                        else
                            throw ("Dictionary is read only! Check IsReadOnly value.");
                    },

                    Item: function(key) {
                        if (!key)
                            throw ("Invalid key! Key value is: " + key);

                        for (var index = 0; index < this._dictionary.length; index++) {
                            if (this._dictionary[index].key == key)
                                return this._dictionary[index].value;
                        }
                        return null;
                    },

                    CopyTo: function(array, arrayIndex) {
                        if (!array)
                            throw ("Destination array is null!");
                        if (arrayIndex < 0 || arrayIndex > array.length)
                            throw ("Index of destination array out of bound! Index value is: " + arrayIndex);

                        for (var i = this._dictionary.length - 1; i >= 0; i--)
                            array.splice(arrayIndex, 0, this._dictionary[i]);
                    },

                    Count: function() {
                        return this._dictionary.length;
                    },

                    Keys: function() {
                        var keys = [];
                        for (var index = 0; index < this._dictionary.length; index++)
                            keys.push(this._dictionary[index].key);

                        return keys.reverse();
                    },

                    Values: function() {
                        var values = [];
                        for (var index = 0; index < this._dictionary.length; index++)
                            values.push(this._dictionary[index].value);

                        return values.reverse();
                    },

                    IndexOf: function(key) {
                        var keys = [];
                        for (var index = 0; index < this._dictionary.length; index++) {
                            if (this._dictionary[index].key == key)
                                return index;
                        }
                    },

                    InsertAt: function(index, key, value) {
                        if (!this.IsReadOnly) {
                            if (index < 0 || index >= this._dictionary.length)
                                throw ("Index out of bound! Index value is: " + index);

                            var dicEntry = new MG.Collections.DictionaryEntry(key, value);
                            this._dictionary.splice(index, 0, dicEntry);
                        }
                        else
                            throw ("Dictionary is read only! Check IsReadOnly value.");
                    },

                    Reverse: function() {
                        if (!this.IsReadOnly)
                            this._dictionary.reverse();
                        else
                            throw ("Dictionary is read only! Check IsReadOnly value.");
                    }
                }, null, [MG.Collections.IDictionary, MG.Collections.ICollection]);

/******************************************************************************/
// Comparer class definition.
// Implements interfaces: IComparer
/******************************************************************************/
MG.Collections.Comparer = MG.Class.Create({
    constructor: function() { },
    Compare: function(object1, object2) {
        var result = false;
        var type = typeof object1;
        if (type !== typeof object2)
            throw ("Object 'object1' doesn't have same type as object 'object2'!");
        else if (type === "object") {
            switch (object1.constructor) {
                case Array:
                    {
                        if (object1.length === object2.length) {
                            for (var index = 0; index < object1.length; index++) {
                                result = this.Compare(object1[index], object2[index]);
                                if (!result)
                                    break;
                            }
                        }
                    }
                    break;
                case Dictionary:
                    {
                        if (object1.Count() === object2.Count()) {
                            var keys = object1.Keys();
                            for (var index = 0; index < keys.length; index++) {
                                if (object2.Contains(keys[index])) {
                                    result = this.Compare(object1.Item(keys[index]),
                                                                                        object2.Item(keys[index]));

                                    if (!result)
                                        break;
                                }
                                else {
                                    result = false;
                                    break;
                                }
                            }
                        }
                    }
                    break;
                case ArrayList:
                    {
                        if (object1.Count() === object2.Count()) {
                            for (var index = 0; index < object1.Count(); index++) {
                                result = this.Compare(object1.Item(index), object2.Item(index));

                                if (!result)
                                    break;
                            }
                        }
                    }
                    break;
                default:
                    {
                        if (object1 === object2)
                            result = true;
                    }
                    break;
            }
        }

        switch (type) {
            case "string":
            case "number":
            case "boolean":
                if (object1 === object2)
                    result = true;
                break;
        }

        return result;
    }
}, null, [MG.Collections.IComparer]);


MG.Collections.TypedCollection = MG.Class.Create({
    Type: null,
    Browser: null,

    constructor: function(type) {
        var _type = typeof type;
        if (_type && _type === "function")
            this.Type = type;
        else
            throw ("The 'type' parameter must be a function object.");

        this.Browser = MG.Browser.getInstance();
    },

    Add: function() {
        var key = null;
        var value = null;

        if (arguments.length == 2) {
            key = arguments[0];
            value = arguments[1];
        }
        else if (arguments.length == 1)
            value = arguments[0];
        else
            throw ("Invalid number of parameters. Number of parameters expected is two or one.");

        if (this.Browser.NS) {
            if (value.constructor !== this.Type.constructor)
                throw ("The 'value' parameter doesn't have same type as this collection.");
        }
        else if (this.Browser.IE) {
            if (value.constructor !== this.Type)
                throw ("The 'value' parameter doesn't have same type as this collection.");
        }

        if (!this.IsReadOnly) {
            if (key) {
                var dicEntry = new MG.Collections.DictionaryEntry(key, value);
                this._dictionary.push(dicEntry);
            }
            else {
                var dicEntry = new MG.Collections.DictionaryEntry("key", value);
                this._dictionary.push(dicEntry);
            }
        }
        else
            throw ("Dictionary is read only! Check IsReadOnly value.");
    },

    Item: function() {
        if (!arguments.length == 1)
            throw ("Invalid number of parameters. Number of parameters expected is two or one.");

        var arg = arguments[0];
        var type = typeof arg;
        var value = null;

        if (type == "string")
            value = this.___Item(arg);
        else if (type == "number") {
            if (this._dictionary.length > arg)
                value = this._dictionary[arg].value;
            else
                throw ("Index is out of range.");
        }

        return value;
    }

}, MG.Collections.Dictionary, null);

JavaScript XML Document and XPath

2009-12-13T09:51:00.000-08:00

Here is a small library/wrapper for JavaScript XML. Some parts of it belong to other authors like the Opera serialization and the loading of the XML document from a string. I had to do a lot of work on the part related to namespaces, especially on Opera. At this time, the library doesn’t work under Chrome if the XML document makes use of namespaces. So you will not be able to create XPath expression for namespace-d XML documents under Chrome browser. You will notice that the library exposes two layers, first of them is an abstraction of the native DOM and of all its functionality and the second one is the native DOM its self. I have used this library for different XML related tasks; the most important one in my case is the SOAP library and the .NET DataSet serialization to JavaScript data objects. I’m too lazy to explain it in details, but if you have questions feel free to ask them and I’ll give you an answer as fast as possible. You can download the source from HERE

if (typeof (MG) == 'undefined')
    throw ("MG.Core.js is required!");
    
if(typeof(MG.Collections) === 'undefined')
    throw ("MG.Collections.js is required!");    
    
if (typeof (MG.Xml) == 'undefined')
    MG.Xml = {};

MG.Xml.XmlDocument = function(rootTagName, namespaceURL)
        {
            if(document.implementation && document.implementation.createDocument)
            {
                Document.prototype.loadXML = function(strXML)
                {
                    var domParser = new DOMParser();
                    var xmlDoc = domParser.parseFromString(strXML, "text/xml");
                                                    
                    while(this.hasChildNodes())
      this.removeChild(this.lastChild);
                                                        
                    for(var index = 0; index < xmlDoc.childNodes.length; index++)
                    {
      var impNode = this.importNode(xmlDoc.childNodes[index], true);
                        this.appendChild(impNode);
                    }
                                                    
                    var nsResolvers = new MG.Collections.Dictionary();
                    if(xmlDoc.childNodes.length > 0)
                    {
      nsResolvers = fixNS(strXML);
                    }
                                                    
                    function fixNS(xml)
                    {
      var regEx = /<[a-z\dA-Z\d]+:/g;
                        var results = xml.match(regEx);
                        var prefixes = new MG.Collections.ArrayList();
                        var resolvedPrefixes = new MG.Collections.ArrayList();
                        var unresolvedPrefixes = new MG.Collections.ArrayList();
                                                        
                        var count = results !== null ? results.length : 0;
                        for(var index = 0; index < count; index++)
                        {
       var matchValue = results[index];
       var value = matchValue.slice(1, matchValue.length - 1);
                                                            
                            if(prefixes.IndexOf(value) < 0)
        prefixes.Add(value);
                        }
                                                        
                        regEx = /:[a-zA-Z]+=|[a-zA-Z]+=/g;
                        results = xml.match(regEx);
                                                        
                        count = results !== null ? results.length : 0;
                        var prefixesCount = prefixes.Count();
                        for(var index = 0; index < prefixesCount; index++)
                        {
       var resolved = false;
                            var prefix = prefixes.Item(index);
                            for(var j = 0; j < count; j++)
                            {
        var attribute = results[j];
                                var value= null;
                                if(attribute.indexOf(":") === 0)
         value = attribute.slice(1, attribute.length - 1);
                                else
                                    value = attribute.slice(0, attribute.length - 1);
                                                                    
                                if(prefix === value)
        {
         if(resolvedPrefixes.IndexOf(value) < 0)
          resolvedPrefixes.Add(prefixes.Item(index));
                                                                    
         resolved = true;
                                }
                                else
                                {
                                    if(resolvedPrefixes.IndexOf(value) < 0)
          resolvedPrefixes.Add(value);
                                }
                            }
                                                             
                            if(!resolved)
                            unresolvedPrefixes.Add(prefixes.Item(index));
                        }
                                                         
                        var uniqueNamespaces = new MG.Collections.Dictionary();
                                                         
                        var exPrefixesCount = resolvedPrefixes.Count();
                        for(var index = 0; index < exPrefixesCount; index++)
                        {
       var prefix = resolvedPrefixes.Item(index);
                            var regexS = "\\b" + prefix + "=\s*\".*?\"";
                            var regex = new RegExp(regexS);
                            var results = regex.exec(xml);
                                                            
                            if(results !== null && results.length > 0)
                            {
        var prefixValues = new MG.Collections.ArrayList();
                                for(var j = 0; j < results.length; j++)
                                {
         var value = results[j].substring(prefix.length + 2, results[j].length - 1);
                                    prefixValues.Add(value);
                                }
                                                                
        uniqueNamespaces.Add(prefix, prefixValues);
                            }
                        }
                                                         
       return uniqueNamespaces;
                    }
                                                    
                    function createNSResolvers(node)
                    {
      var childNodes = node.childNodes;
                        for(var index = 0; index < childNodes.length; index++)
                        {
                            var prefix = childNodes[index].prefix;
                            var nsURI = childNodes[index].namespaceURI;
                                                            
                            if(prefix && nsURI)
                            {
        if(!nsResolvers.Item(prefix))
         nsResolvers.Add(prefix, nsURI);
                            }
                                                            
                            createNSResolvers(childNodes[index]);    
                        }
                    }
                                                    
      this.nsResolvers = nsResolvers;
                }
                
                function __getXml()
                {
                    var xmlSerializer = new XMLSerializer();
                    var xml = xmlSerializer.serializeToString(this);
                    return xml;
                }
                
                if(Node.prototype.__defineGetter__)                                
                    Node.prototype.__defineGetter__("xml", __getXml);
                
                return new MG.Xml.XmlNode(document.implementation.createDocument(namespaceURL, rootTagName, null)); 
            }
            else
            {
                var doc = new ActiveXObject("MSXML2.DOMDocument");
                
                if(rootTagName)
                {
                    var prefix = "";
                    var tagName = rootTagName;
                    var pos = rootTagName.indexOf(":");
                    
                    if(pos != -1)
                    {
                        rootTagName = rootTagName.substring(0, pos);
                        tagName = rootTagName.substring(pos + 1);
                    }
                 
                    if (namespaceURL)
                    { 
                        if (!prefix)
                            prefix = "a0";
                    }
                    else
                        prefix = ""; 

                    var text = "<" + (prefix?(prefix+":"):"") + tagName +
                                (namespaceURL?(" xmlns:" + prefix + '="' + namespaceURL +'"'):"") + "/>";
            
                    doc.loadXML(text);
                }
                
                return new MG.Xml.XmlNode(doc); 
            }

        };
        

MG.Xml.XmlNode = function(nativeNode)
    {
        if(nativeNode)
        {
            this.NativeNode = nativeNode;
            this.NativeAttributes = nativeNode.attributes;
            this.NativeChildNodes = nativeNode.childNodes;
        }
    };

MG.Xml.XmlNode.prototype.mdcXPath = function(node, xpathExpression, queryType)
    {
        var xpe = new XPathEvaluator();
        var nsResolver = function(prefix)
                { 
                    var nsResolvers = node.nsResolvers;
                    if(!nsResolvers)
                        nsResolvers = node.ownerDocument.nsResolvers;
                    var item = nsResolvers.Item(prefix);
                    
                    if(item)
                    {
                        if (item.Count() > 0) 
                        {
                            return item.Item(0); 
                        }
                    }
                    else
                        return xpe.createNSResolver(node.ownerDocument == null ? node.documentElement : node.ownerDocument.documentElement);
                };
        
        var result = xpe.evaluate(xpathExpression, node, nsResolver, queryType, null);
        return result;
    };

MG.Xml.XmlNode.prototype.fixNameSpaces = function(node, nsResolvers, xml)
    {
        if(nsResolvers)
        {
            if(node.prefix)
            {
                var nsResolver = nsResolvers.Item(node.prefix);
                if(nsResolver)
                {
                    xml += " " + "xmlns:" + node.prefix + "=\"" + nsResolver + "\"";
                    nsResolvers.Remove(node.prefix);
                }
            }
            
            for(var index = 0; index < node.childNodes.length; index++)
                xml = this.fixNameSpaces(node.childNodes[index], nsResolvers, xml);
        }
            
        return xml;
    }

MG.Xml.XmlNode.prototype.operaSerialize = function(nativeNode)
    {
        var xml = null;
        switch(nativeNode.nodeType) 
        {
            case 1:
                {
                    if(this.Name() === nativeNode.nodeName)
                        xml = "<" + nativeNode.localName;
                    else
                        xml = "<" + nativeNode.tagName;
                    
                    var nsResolvers = null;
                    var xmlnsAdded = false;
                    
                    for (var i = 0; i < nativeNode.attributes.length; i++) 
                    {
                        var localName = nativeNode.attributes[i].localName;
                        var name = nativeNode.attributes[i].name;
                        var value = nativeNode.attributes[i].value;
                        
                        if(this.Name() === nativeNode.nodeName)
                        {
                            if(nativeNode.ownerDocument)
                            {
                                nsResolvers = nativeNode.ownerDocument.nsResolvers;
                                if(nsResolvers && nativeNode.ownerDocument.nsResolvers.Contains(localName))
                                    nsResolvers.Remove(localName);
                            }
                            else
                            {
                                nsResolvers = nativeNode.nsResolvers;
                                if(nsResolvers && nsResolvers.Contains(name))
                                    nsResolvers.Remove(name);
                            }
                        }
                        
                        if(name === "xmlns")
                            xmlnsAdded = true;
                        
                        xml += " " + name + "=\"" + value + "\"";
                    }
                    
                    if(this.Name() === nativeNode.nodeName)
                    {
                        if(!nsResolvers)
                        {
                            if(nativeNode.ownerDocument)
                                nsResolvers = nativeNode.ownerDocument.nsResolvers;
                            else
                                nsResolvers = nativeNode.nsResolvers;
                        }
                        
                        if(nsResolvers)
                        {
                            var item = nsResolvers.Item("xmlns");
                            if(item)
                                xml += " " + "xmlns" + "=\"" + item + "\"";
                            else if(!xmlnsAdded)
                                xml += " " + "xmlns" + "=\"" + "http://tempuri.org/" + "\"";
                        
                            xml = this.fixNameSpaces(nativeNode, nsResolvers, xml);     
                        } 
                    }
                                       
                    xml += ">";
            
                    for (var i = 0; i < nativeNode.childNodes.length; i++)
                        xml += this.operaSerialize(nativeNode.childNodes[i]);
                    
                    if(this.Name() === nativeNode.nodeName)
                        xml += "</" + nativeNode.localName + ">";
                    else
                        xml += "</" + nativeNode.tagName + ">";
                }
             break;
            case 3:
                    xml = nativeNode.nodeValue;
             break;
         case 4:
                    xml = "<![CDATA[" + nativeNode.nodeValue + "]]>";
             break;
         case 7:
                 xml = "<?" + nativeNode.nodevalue + "?>";
             break;
         case 8:
                 xml = "<!--" + nativeNode.nodevalue + "-->";
                break;
            case 9:
                {
                    for (var i = 0; i < nativeNode.childNodes.length; i++)
                        xml += this.operaSerialize(nativeNode.childNodes[i]);
                }
                break;   
        }
        return xml;  
    };

MG.Xml.XmlNode.prototype.ChildNodes = function(index)
    {
        if(this.NativeChildNodes)
        {
            if(arguments.length === 0)
                return new MG.Xml.XmlNodes(this.NativeChildNodes);
            else
            {
                var nativeNode = this.NativeChildNodes[index];
                return (new MG.Xml.XmlNode(nativeNode));
            }
        }
        
        return null;
    };
    
MG.Xml.XmlNode.prototype.NextSibling = function()
    {
        if(this.NativeNode)
            return new MG.Xml.XmlNode(this.NativeNode.nextSibling);
        
        return null;
    };
    
MG.Xml.XmlNode.prototype.FirstChild = function()
    {
        if(this.NativeNode)
            return new MG.Xml.XmlNode(this.NativeNode.firstChild);
        
        return null;
    };

MG.Xml.XmlNode.prototype.Name = function()
    {
        if(this.NativeNode)
        {
            var browser = MG.Browser.getInstance();
            if(browser.NS || browser.OPERA)
                return this.NativeNode.nodeName;
            else if(browser.IE)
                return this.NativeNode.nodeName;
        }
       
        return null;
    };
    
MG.Xml.XmlNode.prototype.LocalName = function()
    {
        if(this.NativeNode)
        {
            var browser = MG.Browser.getInstance();
            if(browser.NS || browser.OPERA)
                return this.NativeNode.localName;
            else if(browser.IE)
                return this.NativeNode.baseName;
        }
        
        return null;
    };
    
MG.Xml.XmlNode.prototype.Text = function()
    {
        if(this.NativeNode)
        {
            var browser = MG.Browser.getInstance();
            
            if(arguments.length === 1)
            {
                if(browser.NS || browser.OPERA)
                    return this.NativeNode.textContent =  arguments[0];
                else if(browser.IE)
                    return this.NativeNode.text = arguments[0];
            }
            else if(arguments.length === 0)
            {
                if(browser.NS || browser.OPERA)
                    return this.NativeNode.textContent;
                else if(browser.IE)
                    return this.NativeNode.text;
            }
            else
                throw("Only one parameter is expected.");
        }
        
        return null;
    };
    
MG.Xml.XmlNode.prototype.Value = function()
    {
        if(this.NativeNode)
        {
            if(arguments.length === 1)
                this.NativeNode.nodeValue = arguments[0];
            else if(arguments.length === 0)
                return this.NativeNode.nodeValue;
            else
                throw("Only one parameter is expected.");
        }
    };    
    
MG.Xml.XmlNode.prototype.Xml = function()
    {
        if(this.NativeNode)
        {
            var browser = MG.Browser.getInstance();
            if(browser.NS || browser.IE)
                return this.NativeNode.xml;
            else if(browser.OPERA)
                return this.NativeNode.xml;
        }
        
        return null;
    };

MG.Xml.XmlNode.prototype.SelectSingleNode = function(xpathExpression)
    {
        if(this.NativeNode)
        {
            var nativeNode = null;
            var browser = MG.Browser.getInstance();
            if(browser.NS || browser.OPERA)
            {
                var result = this.mdcXPath(this.NativeNode, xpathExpression, XPathResult.FIRST_ORDERED_NODE_TYPE);
                nativeNode = result ? result.singleNodeValue : null;
            }
            else if(browser.IE)
                nativeNode = this.NativeNode.selectSingleNode(xpathExpression);
            
            if(nativeNode)
                return new MG.Xml.XmlNode(nativeNode);  
        }
        
        return null;
    };
    
MG.Xml.XmlNode.prototype.SelectNodes = function(xpathExpression)
    {
        if(this.NativeNode)
        {
            var nativeNodes = null;
            var browser = MG.Browser.getInstance();
            if(browser.NS || browser.OPERA)
            {
                var result = this.mdcXPath(this.NativeNode, xpathExpression, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE);
                
                if(result)
                {
                    var pseudoNodes = new MG.Collections.ArrayList();
                    for(var index = 0; index < result.snapshotLength; index++)
                        pseudoNodes.Add(new MG.Xml.XmlNode(result.snapshotItem(index)));
                        
                   nativeNodes = pseudoNodes;
                }
            }
            else if(browser.IE)
                nativeNodes = this.NativeNode.selectNodes(xpathExpression);
            if(nativeNodes)
                return new MG.Xml.XmlNodes(nativeNodes);
        }
                
        return null;
    };
    
MG.Xml.XmlNode.prototype.CreateNode = function(type, name, namespaceURI)
    {
        if(this.NativeNode)
        {
            var nativeNode = this.NativeNode.createNode(type, name, namespaceURI);
            if(nativeNode)
                return new MG.Xml.XmlNode(nativeNode);
        }
                
        return null;
    };
    
MG.Xml.XmlNode.prototype.AppendChild = function(node)
    {
        if(this.NativeNode)
            this.NativeNode.appendChild(node.NativeNode);
    };
    
MG.Xml.XmlNode.prototype.RemoveChild = function(node)
    {
        if(this.NativeNode)
            this.NativeNode.removeChild(node.NativeNode);
    };
    
MG.Xml.XmlNode.prototype.ReplaceChild = function(newNode, oldNode)
    {
        if(this.NativeNode)
            this.NativeNode.replaceChild(newNode.NativeNode, oldNode.NativeNode);
    };
    
MG.Xml.XmlNode.prototype.ParentNode = function()
    {
        if(this.NativeNode)
            return new MG.Xml.XmlNode(this.NativeNode.parentNode);
                
        return null;
    };
    
MG.Xml.XmlNode.prototype.Prefix = function()
    {
        if(this.NativeNode)
            return this.NativeNode.prefix;
                
        return null;
    };
    
MG.Xml.XmlNode.prototype.LoadXML = function(xmlString)
    {
        this.NativeNode.loadXML(xmlString);
    };

MG.Xml.XmlNode.prototype.SetAttributeNode = function(attributeNode)
    {
        if(this.NativeNode)
            this.NativeNode.setAttributeNode(attributeNode.NativeAttribute);
    };
    
MG.Xml.XmlNode.prototype.SetAttribute = function(name, value)
    {
        if(this.NativeNode)
            this.NativeNode.setAttribute(name, value);
    };    
    
MG.Xml.XmlNode.prototype.Attributes = function()
    {
        if(this.NativeAttributes)
            return new MG.Xml.Attributes(this.NativeAttributes);
            
        return null;
    };
    
MG.Xml.Attributes = function(nativeAttributes)
    {
        this.NativeAttributes = nativeAttributes;
    };

MG.Xml.Attributes.prototype.GetNamedItem = function(itemName)
    {
        if(this.NativeAttributes)
           return new MG.Xml.Attribute(this.NativeAttributes.getNamedItem(itemName));
           
       return null;
    };
    
MG.Xml.Attributes.prototype.Item = function(index)
    {
        if(this.NativeAttributes)
            return new MG.Xml.Attribute(this.NativeAttributes[index]);
            
        return null;
    };
    
MG.Xml.Attributes.prototype.Length = function()
    {
        if(this.NativeAttributes)
            return this.NativeAttributes.length;
            
        return null;
    };
    
MG.Xml.Attribute = function(nativeAttribute)
    {
        this.NativeAttribute = nativeAttribute;
    };
    
MG.Xml.Attribute.prototype.Value = function()
    {
        if(this.NativeAttribute)
            return this.NativeAttribute.value;
    };

MG.Xml.Attribute.prototype.Name = function()
    {
        if(this.NativeAttribute)
            return this.NativeAttribute.name;
    };

MG.Xml.XmlNodes = function(nativeNodes)
    {
        var isPseudo = false;
        var browser = MG.Browser.getInstance();
        if(browser.NS || browser.OPERA)
        {
            if(nativeNodes.constructor === MG.Collections.ArrayList.constructor)
                isPseudo = true;
        }
        else if(browser.IE)
        {
            if(nativeNodes.constructor === MG.Collections.ArrayList)
                isPseudo = true;
        }
        
        if(!isPseudo)
        {
            this.NativeNodes = new MG.Collections.ArrayList();
            for(var index = 0; index < nativeNodes.length; index++)
                this.NativeNodes.Add(new MG.Xml.XmlNode(nativeNodes[index]));
        }
        else
            this.NativeNodes = nativeNodes;
    };
   
MG.Xml.XmlNodes.prototype.Length = function()
    {
        if(this.NativeNodes)
        {
            var browser = MG.Browser.getInstance();
            if(browser.NS || browser.OPERA)
            {
                if(this.NativeNodes.constructor === MG.Collections.ArrayList.constructor)
                    return this.NativeNodes.Count();
                else
                    return this.NativeNodes.length;
            }
            else if(browser.IE)
            {
                if(this.NativeNodes.constructor === MG.Collections.ArrayList)
                    return this.NativeNodes.Count();
                else    
                    return this.NativeNodes.length;
            }
        }
            
        return null;
    };
    
MG.Xml.XmlNodes.prototype.Item = function(index)
    {
        if(this.NativeNodes)
            return this.NativeNodes.Item(index);    
        
        return null;
    };

Google - Google Shit

2009-12-09T06:09:00.000-08:00

Today I tried to create a Gmail account for a friend of mine. I was stupefied when I saw that they require you to provide your phone number to confirm that you are not a spammer. This is crap, the capcha is more than enough to do the job. They are going to far this time.

BWOOOOO!!

JavaScript Mugen Library Benchmark

2009-12-09T01:56:00.000-08:00

Here are the benchmark results from JSLitmus for JavaScript inheritance from Mugen library which I have presented in the previous posts compared with other existing JavaScript libraries.

1. Results for IE7

2. Results for Mozilla

3. Results for Opera

4. Results for Safari

JavaScript Inheritance Part II

2009-12-08T09:38:00.000-08:00

Here are two different approaches in using the previous motioned inheritance technique.

1. Standard way where all members are public:

var Human = MG.Class.Create({
                Gender: null,
                constructor: function(gender) {
                    this.Gender = gender;
                },

                IsMale: function() {
                    return this.Gender == 'F' ? false : true;
                },

                GenderString: function() {
                    return this.Gender == 'F' ? "female" : "male";
                },

                ToOverride: function() { return "Called from Human"; }
            }, null, null);
            
            var Individual = MG.Class.Create({
                Unique: null,
                constructor: function(unique) {
                    this.Unique = unique;
                },

                IsUnique: function() {
                    return this.Unique ? "Yes" : "No";
                },

                DummyMethod: function() {
                    return "Individual dummy method.";
                },

                ToOverride: function() { return "Called from Individual which is " + (this.Unique ? "unique" : "not unique") + " / " + this.base(); }
            }, Human, null);

            var Person = MG.Class.Create({
                constructor: function(firstName, lastName, birthDate) {
                    this.FirstName = firstName;
                    this.LastName = lastName;
                    this.BirthDate = birthDate;
                },

                GetName: function() {
                    return this.FirstName + " " + this.LastName;
                },

                GetDetails: function() {
                    return this.GetName() + " it's a " + this.GenderString() + " borned on date " + this.BirthDate;
                },

                ToOverride: function() { return "Called from Person with first name " + this.FirstName + " / " + this.base(); }
            }, Individual, null);

            var Jhon = MG.Class.Create({
                constructor: function(age) {
                    this.Age = age;
                },

                GetDetails: function() {
                    return this.GetName() + " it's a " + this.GenderString() + " borned on date " + this.BirthDate + ".";
                },

                ToOverride: function() { return "Called from Jhon/ " + this.base(); }
            }, Person, null);

2. Classes with private members:

var Human = MG.Class.Create({
                constructor: function(gender) {
                    this.Gender = gender;

                    return { IsMale: function() {
                        return this.Gender == 'F' ? false : true;
                    },

                        GenderString: function() {
                            return this.Gender == 'F' ? "female" : "male";
                        },

                        ToOverride: function() { return "Called from Human"; } 
                    };
                }
            }, null, null);

            var Individual = MG.Class.Create({
                constructor: function(unique) {
                    this.Unique = unique;
                    
                     var PrivateDummyMethod = function() {
                            return "Individual dummy method.";
                        };

                    return { IsUnique: function() {
                        return this.Unique ? "Yes" : "No";
                    },

                        ToOverride: function() { return "Called from Individual / " + this.base(); } 
                    };
                }
            }, Human, null);

            var Person = MG.Class.Create({
                constructor: function(firstName, lastName, birthDate) {
                    this.FirstName = firstName;
                    this.LastName = lastName;
                    this.BirthDate = birthDate;

                    return { GetName: function() {
                        return this.FirstName + " " + this.LastName;
                    },

                        GetDetails: function() {
                            return this.GetName() + " it's a " + this.GenderString() + " borned on date " + this.BirthDate;
                        },

                        ToOverride: function() { return "Called from Person / " + this.base(); } 
                    };
                }
            }, Individual, null);

            var Kate = MG.Class.Create({
                constructor: function(age) {
                    this.Age = age;

                    return { GetDetails: function() {
                                    return this.GetName() + " it's a " + this.GenderString() + " borned on date " + this.BirthDate + ".";
                                },

                            ToOverride: function() { return "Called from Kate/ " + this.base(); }};
                }
            }, Person, null);

I observed one thing about Base2 and Prototype. When you call a chain method and you reach the parent method, inside the method you have access to the derived object members using “this”. In my opinion once the call is navigating thru the chain on each base class the user should not be able to access the derived class members based on OOP definitions. In the future I'll fix this also in my technique.

JavaScript Inheritance Part I

2009-12-08T06:35:00.000-08:00

As a background I’m a .NET developer (C#) and I really like this technology :D. Since I got in contact with JavaScript, I always wanted to find an approach, a way to adapt it and used it as more as possible as an object oriented programming language. I found different approaches/techniques regarding this aspect of JavaScript (Crockford inheritance, Dean Edward with base2, Prototype, John Resig with a mixture of base2 and Prototype). After I studied the previous mentioned techniques I decided to have fun by trying to create a mixture and add new desired functionality. You can download the source from HERE

For example in the case of Base2 inheritance you can’t create an object which has private and public members in a elegant way. Let us assume that we have following object:

var Human = base2.Base.extend({
             constructor: function(name, hairColour, eyeColour, height, weight) {
                 this.Name = name;
                        this.HairColour = hairColour;
                        this.EyeColour =  eyeColour;
                        this.Height =  height;
                        this.Weight =  weight},
                    IsHeavy: function() {
                        return this.Weight > 100 ? true : false;
                    },
                    Dance: function() {
                        return this.Name + " is dancing!";
                    }});

In this case all members of the Human class are public. If I try to make Dace member private in the following way then all public members will not be available to the descendant of the Human class.

var Human = base2.Base.extend({
             constructor: function(name, hairColour, eyeColour, height, weight) {
    var Dance = function() {
                        return this.Name + " is dancing!";};
    
                 return{Name: name,
                        HairColour: hairColour,
                        EyeColour: eyeColour,
                        Height:  height,
                        Weight:  weight,
      IsHeavy: function() {
                        return this.Weight > 100 ? true : false;
      }};
    });

To test this case I have created a class called Person which extends the Human. Here is the code:

var Person = Human.extend({
             constructor: function(name, hairColour, eyeColour, height, weight) {
    this.base(name, hairColour, eyeColour, height, weight);
    },
                    IsUnique: function() {
                        return true;
                    }});

var obj = new Person("Bob Doe", "brown'", "blue", 6, 12);
obj.IsHeavy();

So, to extend the functionality to cover the above mentioned scenario I have used a different approach for inheritance. In this way the public members of a base class declared as in the above example and also those declared using prototype will be inherited by the derived class.

Here is the code which I will discuss it later on:

MG.Class.Create = function() {
    var ___descendant = arguments[0];
    var ___parent = arguments[1];
    var interfaces = arguments[2];
    var Implements = MG.Class.Implements;

    var instance = function() {
        // Copy 'base' (overridden) properties
        this.base = instance.base;

        // Copy properties from 'instance'
        // structure object
        for (var prop in instance) {
            this[prop] = instance[prop];
        }

        var publicParentProps = [];
        /**********************************************/
        // Create the appropriate arguments and
        // initialize ___parent/___descendant by calling
        // their constructors
        /**********************************************/
        var args = arguments;
        var desArgsCount = ___descendant.constructor.length;
        var desArgs = new Array(desArgsCount);

        for (var index = 0; index < desArgsCount; index++)
            desArgs[index] = args[index];

        if (this.base && this.base.inheritanceList) {
            var length = this.base.inheritanceList.length;
            var startParams = args.length;
            for (var k = 0; k < length; k++) {
                var ctor = this.base.inheritanceList[k];
                var prnArgsCount = ctor.length;
                var prnArgs = new Array(prnArgsCount);

                startParams -= prnArgsCount;
                var nextParams = prnArgsCount > startParams ? (startParams + prnArgsCount) : (startParams - prnArgsCount);
                for (var index = startParams, i = 0; (prnArgsCount > startParams ? index < nextParams : index > nextParams); (prnArgsCount > startParams ? index++ : index--)) {
                    prnArgs[i] = args[Math.abs(index)];
                    i++;
                }

                var publicParentProp = ctor.apply(this, prnArgs);
                if (publicParentProp) {
                    if (publicParentProps.length > 0)
                        publicParentProps[publicParentProps.length] = publicParentProp;
                    else
                        publicParentProps[0] = publicParentProp;
                }

                this.base.inheritanceList[k] = null;
            }

            this.base.inheritanceList = null;
            delete this.base.inheritanceList;
        }

        var publicDescendant = instance.constructor.apply(this, desArgs);

        if (publicDescendant) {
            for (var prop in publicDescendant)
                this[prop] = publicDescendant[prop];
        }

        if (publicParentProps) {
            var length = publicParentProps.length;
            for (var index = 0; index < length; index++) {
                var publicParentProperty = publicParentProps[index];
                for (var prop in publicParentProperty) {
                    if (!this[prop])
                        this[prop] = publicParentProperty[prop];
                    else {
                        this.base[prop] = publicParentProperty[prop];
                    }
                }
            }
        }
        return this;
    };

    /**************************************************/
    // Create the structure of the object
    // which will be instantiated
    /**************************************************/
    // Set the constructor from the ___descendant
    instance.constructor = ___descendant.constructor;

    // Copy peoperties from ___descendant
    for (var prop in ___descendant)
        instance[prop] = ___descendant[prop];

    if (___parent) {
        // Create a 'base' function which will hold properties
        // overridden by the ___descendant
        instance.base = function() {
            var overrideFunction = null;
            for (var prop in this) {
                if (typeof (this[prop]) !== 'function')
                    instance.base[prop] = this[prop];
                else if (this[prop] === arguments.caller.callee)
                    overrideFunction = prop;
            }

            if (overrideFunction)
                instance.base[overrideFunction]();
        };

        var inheritanceList = new Array();
        if (___parent.base && ___parent.base.inheritanceList) {
            var parentInheritanceList = ___parent.base['inheritanceList'];
            var length = parentInheritanceList.length;

            for (var index = 0; index < length; index++)
                inheritanceList[index] = parentInheritanceList[index];
        }

        var constructorExists = inheritanceList[inheritanceList.length - 1] === ___parent.constructor;

        if (inheritanceList.length > 0 && !constructorExists)
            inheritanceList[inheritanceList.length] = ___parent.constructor;
        else if (!constructorExists)
            inheritanceList[0] = ___parent.constructor;

        instance.base.inheritanceList = inheritanceList;

        // Copy properties from ___parent
        for (var prop in ___parent) {
            if (!instance[prop])
                instance[prop] = ___parent[prop];
            else {
                if (typeof (___parent[prop]) == 'function')
                    instance.base[prop] = ___parent[prop];
            }
        }

        // Copy properties from ___parent prototype
        if (___parent.prototype) {
            for (var prop in ___parent.prototype) {
                if (!instance[prop])
                    instance[prop] = ___parent.prototype[prop];
                else
                    instance.base[prop] = ___parent.prototype[prop];
            }
        }
    }

    instance.Compare = function(object) {
        for (var prop in this) {
            if (this[prop] === object[prop])
                return false;
        }
        return true;
    }

    return instance;
};

Oracle - Lost package

2009-12-08T06:03:00.000-08:00

Today something very stupid happened. I’ve managed to lose the changes of an entire package. As you know if a package is opened in two different sessions, like session A and session B, if changes are made from session A to the package and session B still has the package opened, when session B will make its changes, all modifications performed by session A on the opened package will be lost. Thanks God that I was able to retrieve the lost changes by making use of SYS.SOURCE$ table. This table is composed from 3 columns: OBJ# which represents the object ID, LINE which is the line number of the source in the object, and SOURCE the column which store the line of code.

SELECT * FROM SYS.SOURCE$;
SELECT * FROM SYS.SOURCE$ WHERE SOURCE LIKE ‘%MYPACKAGE%’;

After digging into the results returned, I was able to find 3 versions of my package. One of them contained the lost changes.

You can find more details about SYS.SOURCE$ table here.

PL/SQL & Oracle 64 bit Client

2009-12-02T04:52:00.000-08:00

At the office I’m using Windows Vista 64 bit, we had a lot of bad surprises when it came to combine 32 bit DLLs from Oracle client with 64 bit DLLs of the projects. The most common exception in which we bumped was “Invalid image format”. We were using Oracle 10.2.0.3 which is a 32 bit client. To solve the issue we had to migrate to Oracle 10.2.0.4 client which has support for 64 bit applications. Once we did this we have discovered other inconvenient, PL/SQL didn't worked at all, the reason…it required a 32 bit Oracle client to be installed on the machine. The only solution found by one of my colleagues is that beside Oracle 10.2.0.4 client we should install also 10.2.0.3. Until now everything works just fine. By the way, same thing applies also to TOAD.

JavaScript Ajax Characterset

2009-12-02T02:14:00.000-08:00

In one of the project I have been involved, I had to create an Ajax menu. The issue showed up when the resource text of the menu items were in Greek. The response of the Ajax request was just junk. The issue resided in the fact that I have not specified on my Ajax request what character set it should be used. The problem was solved once I have specified that the value of charset it should be utf-8.

var url = location.protocol + "//" + location.host + "/MyWebSite/Default.aspx/GetMenuXml";
        
            xmlHttp = GetXmlHttpObject();
            xmlHttp.open("POST", url, true);

            xmlHttp.onreadystatechange = initializeMenu;

            xmlHttp.setRequestHeader("Man", "POST" + url);
            xmlHttp.setRequestHeader("MessageType", "CALL");
            xmlHttp.setRequestHeader("Content-Type", "application/json; charset=utf-8");
                
            xmlHttp.send(null);

JSLitmus creating JavaScript benchmark tests

2009-12-02T00:40:00.000-08:00

Here is a very useful tool which allows you to create nice benchmark tests for your JavaScript code. You can check all the details on their home page:

JSLitmus

JavaScript Get Current Date dd/mm/yyyy

2009-12-01T12:13:00.000-08:00

The followinf function will return current date in dd/mm/yyyy format.

/*Define the namespaces*/
var JavaScript = {};
JavaScript.Utils = {};
JavaScript.Utils.Date = {};

JavaScript.Utils.Date.Current = function(){
  var current = new Date();
  //In JavaScript Date object the months counter starts from 0, so
  //we have to correct this.
  current.setMonth(current.getMonth() + 1);
  var changedDate = current.getDate() + "/" + current.getMonth() + "/" + current.getYear();

  return changedDate;
}

JavaScript Compare Two Dates

2009-12-01T11:56:00.000-08:00

Note: Please check JavaScript Utility Functions Note.

The following javascript function allows you to compare two dates. At this time only dd/mm/yyyy format is supported, but you can extend it very easily. The function will return -1 if first date is smaller than the second date, 1 if it is greater and 0 if both dates are equal.


/*Define the namespaces*/
var JavaScript = {};
JavaScript.Utils = {};
JavaScript.Utils.Date = {};

JavaScript.Utils.Date.Compare = function(firstDate, secondDate, format) {
                if (!(typeof firstDate === "string") || !(typeof secondDate === "string"))
                    throw "Date must be a string.";

                if (!format)
                    throw "invalid date format specified.";

                var result = -1;
                switch (format) {
                    case "dd/mm/yyyy":
                        {
                            var fdate = firstDate.match(/^(\d{2})\/(\d{2})\/(\d{4})$/i);
                            var ldate = secondDate.match(/^(\d{2})\/(\d{2})\/(\d{4})$/i);

                            if (parseInt(fdate[3]) < parseInt(ldate[3]))
                                result = -1;
                            else if (parseInt(fdate[3]) > parseInt(ldate[3]))
                                result = 1;
                            else
                                result = 0;

                            if (result == 0) {
                                if (parseInt(fdate[2]) < parseInt(ldate[2]))
                                    result = -1;
                                else if (parseInt(fdate[2]) > parseInt(ldate[2]))
                                    result = 1;
                                else
                                    result = 0;
                            }

                            if (result == 0) {
                                if (parseInt(fdate[1]) < parseInt(ldate[1]))
                                    result = -1;
                                else if (parseInt(fdate[1]) > parseInt(ldate[1]))
                                    result = 1;
                                else
                                    result = 0;
                            }
                        }
                        break;
                }

        return result;
    };

JavaScript UTC Date Format

2009-12-01T11:39:00.000-08:00

Note: Please check JavaScript Utility Functions Note.

The following javascript function allows you to convert an UTC date into a user specified format. At this time the implementation will convert the UTC date into dd/mm/yyyy and dd/mm/yyyy hh:mm:ss formats. You can easily extend it's functionality.


/*Define the namespaces*/
var JavaScript = {};
JavaScript.Utils = {};
JavaScript.Utils.Date = {};

JavaScript.Utils.Date.UtcFormat = function(utcDate, format) {
if (!(typeof utcDate === "string"))
throw "UTC date must be a string.";

if (!format)
throw "invalid date format specified.";

//Extract UTC date components using regex.
var date = utcDate.match(/^(\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2}):(\d{2}(?:\.\d+)?)(Z(([+-])(\d{2}):(\d{2}))?)$/i);

if (!date)
throw "Invalid UTC date format.";

var newDate = null;
switch (format) {
case "dd/mm/yyyy":
{
newDate = date[3] + "/" + date[2] + "/" + date[1];
}
break;
case "dd/mm/yyyy hh:mm:ss":
{
newDate = date[3] + "/" + date[2] + "/" + date[1] + " " + date[4] + ":" + date[5] + ":" + date[6];
}
break;
}

return newDate;
};

Next JavaScript function will convert date of dd/mm/yyyy format in UTC format. By default the time section will be ignored, being initialized with 00:00:00.


JavaScript.Utils.Date.ToUtcFormat = function(date) {
        if (!(typeof date === "string"))
            throw "Date must be a string.";

        var ndate = date.match(/^(\d{2})\/(\d{2})\/(\d{4})$/i);

        if (!ndate)
            throw "Invalid date format. Format must be dd/mm/yyyy";

        var newDate = ndate[3] + "-" + ndate[2] + "-" + ndate[1] + "T00:00:00Z";

        return newDate;

JavaScript Change URL Parameter Value

2009-12-01T11:09:00.000-08:00

Note: Please check JavaScript Utility Functions Note.

The following function will allow you to change the value of a specified parameter from the URL. You just have to pass the parameter name and desired parameter value.


/*Define the namespaces*/
var JavaScript = {};
JavaScript.Utils = {};
JavaScript.Utils.URL = {};

JavaScript.Utils.URL.ReplaceUrlParam = function(name, value) {
    name = name.replace(/[\[]/, "\\\[").replace(/[\]]/, "\\\]");
    var regexS = "[\\?&]" + name + "=([^&#]*)";
    var regex = new RegExp(regexS);
    var results = regex.exec(window.location.href);
    if (results == null)
        return false;
    else {
        var form = document.forms[0];
        if (form) {
            form.action = form.action.replace(results[0], results[0].replace(/=(.*)/, '=' + value));
        }
    }
};

JavaScript Extract URL Parameter

2009-12-01T10:57:00.000-08:00

Note: Please check JavaScript Utility Functions Note.

The following two functions will allow you to extract a specified parameter from the URL.
To be more precise, only the first one will extract it automatically from the URL, the second function, which is an extension of the first one, will extract the specified parameter value from user defined source which is passed as a parameter.


/*Define the namespaces*/
var JavaScript = {};
JavaScript.Utils = {};
JavaScript.Utils.URL = {};

JavaScript.Utils.URL.GetURLParam = function(param) {
    param = param.replace(/[\[]/, "\\\[").replace(/[\]]/, "\\\]");
    var regexS = "[\\?&]" + param + "=([^&#]*)";
    var regex = new RegExp(regexS);
    var results = regex.exec(window.location.href);

    if (results == null)
        return "";
    else
        return results[1];
};


JavaScript.Utils.URL .GetUrlParamEx = function(source, name) {
  name = name.replace(/[\[]/, "\\\[").replace(/[\]]/, "\\\]");
  var regexS = "[\\?&]" + name + "=([^&#]*)";
  var regex = new RegExp(regexS);
  var results = regex.exec(source);
  if (results == null)
   return "";
  else
  
 return results[1];
};

JavaScript Create Script Node

2009-12-01T10:49:00.000-08:00

Note: Please check JavaScript Utility Functions Note.

Here is short JavaScript function which creates and returns a script node based on the string you specify as parameter:


/*Define the namespaces*/
var JavaScript = {};
JavaScript.Utils = {};
JavaScript.Utils.DOM = {};

JavaScript.Utils.DOM.CreateScriptElement = function(scriptValue) {
    var node = document.createElement("script");
    node.setAttribute('type', 'text/javascript');

    if (node.canHaveChildren == null || node.canHaveChildren)
        node.appendChild(document.createTextNode(scriptValue));
    else
        node.text = scriptValue;

    return node;
};

JavaScript - Utility Functions Note

2009-12-01T10:48:00.000-08:00

First of all I would like to let all of you know that most of the utility functions which I'm going to post here are inspired or are clones of other developer’s pieces of code. By this I have no intention to assume any credit. The reason why their names or web links are not posted is simple, I don't remember them :). If you recognize your work in any of the following lines just let me know.

Garbage Collector (General Overview)

2007-09-03T06:37:00.000-07:00

As you all know any program is using resources. These resources can be files, data base resources, network connections, memory buffers, objects, etc. The usage of any resources requires memory to be allocated. This is achieved using the following steps:

1.Allocate memory for the type that represents the resource by calling newobj intermediate language instruction. This instruction is emitted when you use the new operator.
2.Initialize the memory to make the resource available. The initial state of the resource is created by the constructor of the type.
3.Use the resource by accessing type members.
4.Clean up the resource state.
5.Free the memory occupied by the resource. This task is performed by garbage collector.

The previous steps were generating two major bugs. First, often programmers forgotten to free memory when this was any longer needed. Second, programmers tried to access memory after this was freed. These two cases represent the worst bugs that can reside in an application because the behavior of the application in unpredictable and it's also very difficult to track them.
Resource management it's a difficult task and distracts you, the programmer from the main problems that you have to solve. So this is the reason why garbage collector was created. It will take all the burden of memory handling from your shoulders. You must keep in mind that garbage collector does not knows about a resource that is represented by types in memory. So, this means that it can not clean up the resource in proper manner. This steps must be performed by you, by writing the corresponding code which will clean up the resource. There are two methods that you can make use of to perform the resource cleaning, Finalize and Dispose.

Most types existent in .NET framework do not require resource clean up, types such as Int32, String, ArrayList . But there are also types which wrap some unmanaged resource like a network connection, a database connection, an icon, etc.
The Common Language Runtime also known as CLR requires that all resources to be allocated from the managed heap. This managed heap resembles with the heap from C runtime heap with one major difference, you never free objects from the managed heap, object will be automatically freed when the application doesn't needs them. Now let's see what happens when a process get's initialized. The CLR will reserve a contiguous zone of address space. This address zone represents the managed heap. The managed heap maintains pointer to this address space, we'll call it NextObjectPtr. This pointer indicates where in the managed heap the next object will be allocated. Initially NextObjectPtr points to the base address from the reserved address space. As your intuition tells you, newobj instruction creates a new object. As I have mentioned earlier, this instruction is emitted when you make use of new key word. The newobj instruction will determine the CLR to perform the next steps:

1.Calculate the number of bytes required by the type for which memory will be allocated and also for all it's based types.
2.Add the bytes required for an object overhead. Each object has two overhead fields, a method table pointer and a SyncBLockIndex. If you are using an 32 bit system, each field requires 32 bits, this will add 8 bytes to each object. In the case of a 64 bit system, each field requires 64 bits which will add 16 bytes to each object.
3.CLR then checks if the bytes required to allocate the object are available in the reserved address space (managed heap), if the will fit, then it is allocated at the address pointed by NextObjectPtr, the constructor is called passing NextObjectPtr for this parameter and the new operator will return the address of the object. The NextObjectPtr is moved after the currently allocated object and indicates the address where the next object will be allocated at in the managed heap.

When an application calls the new operator to create a new object there might not be enough space for it. The managed heap checks this by adding the required bytes of the objet to the address in NextObjectPtr. If the value exceeds the address space the managed heap is full and garbage collection takes action.
Garbage collector checks if there are any unused objects in the managed heap. If this kind of objects do exists, then the memory used by them can be reclaimed. If there is no more memory in the heap the new operator will throw an OutOfMemoryException.
An application has a set of roots. A root can be considered to be a memory storage location which contains a pointer to a reference type. This pointer can refer to an object or is set to null if the object doesn't exists. All global or static reference type variables are considered roots also any local variable reference type or parameter variable on a thread stack are considered as being roots. When garbage collector starts running (garbage collector starts when generation 0 of object is full, the garbage collector generation mechanism is used for performance improving, I'm not going to discuss this matter in this article), it will assume that all roots from the managed heap do not refer to any object. The garbage collector starts to iterate thru all roots and creates a graph with all objects that can be reached. In the image objects A and B are directly referenced by the roots so they will be added to the graph. When garbage collector will reach object C it will observer that this objects references another object from the managed heap, object D. So, object will be also added to the garbage collector graph. The entire iteration is performed recursively.

After the graph is completed, this will contain all objects reachable from your application. All other objects which are not a part of this graph are considered garbage. The garbage collector will iterate the heap linearly searching for free large continuous blocks of memory where new object could be allocated. Also garbage collector will shift non garbage objects in memory using memcpy function to compact the memory heap. This operation will make all pointers to objects invalid. So the garbage collector will correct all the invalid pointers. After the managed heap memory is compacted the NextObjectPtr will point exactly after the last non garbage object.
Now that you have a general overview of how garbage collector works you can design you applications properly.
In the next article I will talk with more details about object generations and also about Finalize and Dispose methods and how they should be used.

Logical query processing

2007-08-25T12:35:00.000-07:00

Logical query processing step numbers
(8) SELECT (9) DISTINCT (11)
(1) FROM
(3) JOIN
(2) ON
(4) WHERE
(5) GROUP BY
(6) WITH {CUBE | ROLLUP}
(7) HAVING
(10) ORDER BY

The first noticeable aspect of SQL that is different than other programming languages is the order in which the code is processed. In most programming languages, the code is processed in the order in which it is written. In SQL, the first clause that is processed is the FROM clause, while the SELECT clause, which appears first, is processed almost last.

Each step generates a virtual table that is used as the input to the following step. These virtual tables are not available to the caller (client application or outer query). Only the table generated by the final step is returned to the caller. If a certain clause is not specified in a query, the corresponding step is simply skipped. Following is a brief description of the different logical steps applied in both SQL Server 2000 and SQL Server 2005.

Brief Description of Logical Query Processing Phases

1. FROM: A Cartesian product (cross join) is performed between the first two tables in the FROM clause, and as a result, virtual table VT1 is generated.

2. ON: The ON filter is applied to VT1. Only rows for which the is TRUE are inserted to VT2.

3. OUTER (join): If an OUTER JOIN is specified (as opposed to a CROSS JOIN or an INNER JOIN), rows from the preserved table or tables for which a match was not found are added to the rows from VT2 as outer rows, generating VT3. If more than two tables appear in the FROM clause, steps 1 through 3 are applied repeatedly between the result of the last join and the next table in the FROM clause until all tables are processed.

4. WHERE: The WHERE filter is applied to VT3. Only rows for which the is TRUE are inserted to VT4.

5. GROUP BY: The rows from VT4 are arranged in groups based on the column list specified in the GROUP BY clause. VT5 is generated.

6. CUBE | ROLLUP: Supergroups (groups of groups) are added to the rows from VT5, generating VT6.

7. HAVING: The HAVING filter is applied to VT6. Only groups for which the is TRUE are inserted to VT7.

8. SELECT: The SELECT list is processed, generating VT8.

9. DISTINCT: Duplicate rows are removed from VT8. VT9 is generated.

10. ORDER BY: The rows from VT9 are sorted according to the column list specified in the ORDER BY clause. A cursor is generated (VC10).

11. TOP: The specified number or percentage of rows is selected from the beginning of VC10. Table VT11 is generated and returned to the caller.

Itzik Ben-Gan and Lubor Kollar - Inside Microsoft® SQL Server™ 2005 T-SQL Querying

Auto data binding panel

2007-06-22T03:58:00.000-07:00

Introduction

While I was browsing some old projects of mine, I have discovered that in one of them I have approached an interesting topic of .NET framework. That topic was "Data Binding".

Many of you know that the process of data binding it's a complex one, and differs from web application to windows application, being optimized for each of them. From my point of view data binding can be splinted in two branches: simple data binding and complex data binding.

We can speak about simple data binding when you are in the situation of binding a single value to a property of a control. Simple data binding operation is performed using <%# %>. The expression between data binding tags is evaluated only when the control's data binding method is invoked. Here is an example of simple data binding:

Customer: <%# custID %>

Where "Customer" is a label and "custID" is a public property.
Simple data binding works only with scalar values like strings and integers. Complex data binding is a different story. It works with any data type that implements IEnumerable interface. At the end of this article we should have a panel which will act as a container for the child custom controls and it will automatically fill them with the corresponding values from it's data source. For this to work we need to create two custom interfaces. First of them is IDataBound. IDataBound interface defines the data types (DataTypes) of values that will be bounded to our control, "BoundColumn" property which will keep the name of the column used in binding process, BoundValue property used to store the new value of the control after the binding process. And finally IDataBoundInfo interface which contains the name of the table used in data binding.
Please note that DataTypes enum contains at this time only data types that are found on System.Type. The reason why I have added it to the code is that I might want to use in the feature a custom object as a data type for the data binding.

DataTypes definition

namespace MyControls
{
public enum DataTypes
{
Default,
String,
Integer,
DateTime,
Double
}
}

IDataBound interface definition

namespace MyControls
{
public interface IDataBound
{
DataTypes DataType { get; set; }
string BoundColumn { get; set; }
object BoundValue { get; set; }
bool SingleBind { get; set; }
}
}

IDataBoundInfo interface definition

namespace MyControls
{
public interface IDataBoundInfo : IDataBound
{
string TableName { get; set; }
}
}

BindingTextBox Control

After this short presentation of those two helper interfaces let's get to the business.
I will create a text box custom control, which will be called "BindingTextBox". Here is the code of this control:

using System;
using System.Web.UI.WebControls;

/// <summary>
/// Summary description for BindingTextBox
/// </summary>
namespace MyControls
{
public class BindingTextBox : TextBox, IDataBoundInfo
{
/// <summary>
/// IDataBound members.
/// </summary>
private DataTypes _datatype = DataTypes.Default;
private string _boundcolumn;
private bool _singlebind;

/// <summary>
/// IDataBoundInfo members.
/// </summary>
private string _tablename;

public DataTypes DataType
{
get { return _datatype; }
set { _datatype = value; }
}

public string BoundColumn
{
get { return _boundcolumn; }
set { _boundcolumn = value; }
}

public virtual object BoundValue
{
get { return ControlHelper.ConvertValue
(_datatype, this.Text); }
set
{
if (value is DBNull)
this.Text = "";
else
this.Text = value.ToString();
}
}

public bool SingleBind
{
get { return _singlebind; }
set { _singlebind = value; }
}

public string TableName
{
get { return _tablename; }
set { _tablename = value; }
}

}
}

At this time please ignore SingleBid property, I have used it in other purposes (data binding with multiple values) which I will not describe in this article.

ControlHelper class

I have forgotten to mention about ControlHelper class. If you remember I have made an observation regarding DataTypes enum that at this time
contains only data types that are found on System.Type, and I have give you an explanation also. Same thing goes for ControlHelper class. It contains only one method used for conversion, but if you would have some custom object, you could implement different methods for conversion and not only. Here is the code for ControlHelper class:

using System;

/// <summary>
/// Summary description for ControlHelper
/// </summary>
namespace MyControls
{
public class ControlHelper
{
public static object ConvertValue(DataTypes toType, object value)
{
try
{
switch (toType)
{
case DataTypes.String: return Convert.ToString(value);
case DataTypes.Integer: return Convert.ToInt32(value);
case DataTypes.DateTime:
return Convert.ToDateTime(value);
case DataTypes.Double:
return Convert.ToDouble(value);
case DataTypes.Default: return value;
}
}
catch
{
return null;
}

return null;
}
}
}

I consider that both pieces of code are straight, simple and self explanatory (BindingTextBox and ControlHelper).

BindingPanel Control

The BindingPanel code is more complicated so first I'll show you the code and after I'll present it step by step.

using System;
using System.Collections;
using System.ComponentModel;
using System.Data;
using System.Web.UI;
using System.Web.UI.WebControls;

/// <summary>
/// Summary description for BindingPanel
/// </summary>
namespace MyControls
{
public class BindingPanel : Panel
{
private string _data_member;
private object _datasource;

#region public string DataMember
[Browsable(false)]
public string DataMember
{
get { return _data_member; }
set { _data_member = value; }
}
#endregion

#region public object DataSource
[Browsable(false)]
public object DataSource
{
get { return _datasource; }
set
{
if ((value == null) || (value is IListSource) ||
(value is IEnumerable))
{
_datasource = value;
}
else
throw new ArgumentException(@"Invalid object.
Object must implement IListSource
or IEnumerable", "DataSource");
}
}
#endregion

#region private void UpdateFromControlsRecursive
(Control control, object row)
private void updateFromControlsRecursive
(Control control, object row)
{
foreach (Control ctrl in control.Controls)
{
if (ctrl is IDataBound)
{
IDataBound idbc = (IDataBound)ctrl;
string boundField = idbc.BoundColumn;
object _old_value = null;

if (boundField.Length > 0)
{
if (row is DataRow)
_old_value = ((DataRow)row)[boundField];

if (_old_value != idbc.BoundValue)
{
if (row is DataRow)
{
if (idbc.BoundValue != null)
((DataRow)row)[boundField] =
idbc.BoundValue;
else
((DataRow)row)[boundField] =
DBNull.Value;
}
}

}
}
}
}
#endregion

#region private void BindControlsRecursive(Control control,
object row)
private void bindControlsRecursive(Control control,
object row)
{
foreach (Control ctrl in control.Controls)
{
if (ctrl is IDataBound)
{
IDataBound idbc = (IDataBound)ctrl;
string boundField = idbc.BoundColumn;

if (boundField != null && boundField.Length > 0)
{
if (row is DataRow)
idbc.BoundValue = ((DataRow)row)[boundField];

}
}
}
}
#endregion

#region private void clearControlsRecursive(Control control)
private void clearControlsRecursive(Control control)
{
foreach (Control ctrl in control.Controls)
{
if (ctrl is IDataBound)
{
IDataBound idbc = (IDataBound)ctrl;
string boundField = idbc.BoundColumn;

if (boundField != null && boundField.Length > 0)
idbc.BoundValue = DBNull.Value;
}
}
}
#endregion

#region private PropertyDescriptor[]
GetColumnPropertyDescriptors(object dataItem)
private PropertyDescriptor[]
GetColumnPropertyDescriptors(object dataItem)
{
ArrayList props = new ArrayList();
PropertyDescriptorCollection propDescps =
TypeDescriptor.GetProperties(dataItem);
foreach (PropertyDescriptor pd in propDescps)
{
Type propType = pd.PropertyType;
TypeConverter converter =
TypeDescriptor.GetConverter(propType);

if ((converter != null) &&
converter.CanConvertTo(typeof(string)))
props.Add(pd);
}
props.Sort(new PropertyDescriptorComparer());
PropertyDescriptor[] columns =
new PropertyDescriptor[props.Count];
props.CopyTo(columns, 0);
return columns;
}
#endregion

#region protected virtual IEnumerable GetDataSource()
protected virtual IEnumerable GetDataSource()
{
if (_datasource == null)
return null;
IEnumerable resolvedDataSource = _datasource as IEnumerable;
if (resolvedDataSource != null)
return resolvedDataSource;
IListSource listDataSource = _datasource as IListSource;
if (listDataSource != null)
{
IList listMember = listDataSource.GetList();
if (listDataSource.ContainsListCollection == false)
return (IEnumerable)listMember;
ITypedList typedListMember = listMember as ITypedList;
if (typedListMember != null)
{
PropertyDescriptorCollection propDescps =
typedListMember.GetItemProperties(null);
PropertyDescriptor propertyMember = null;
if ((propDescps != null) && (propDescps.Count != 0))
{
string dataMember = DataMember;
if (dataMember != null)
{
if (dataMember.Length == 0)
propertyMember = propDescps[0];
else
propertyMember =
propDescps.Find(dataMember, true);
if (propertyMember != null)
{
object listRow = listMember[0];
object list =
propertyMember.GetValue(listRow);
if (list is IEnumerable)
return (IEnumerable)list;
}
}
throw new Exception("A list that coresponds to the
selected DataMember cannot be
found.");
}
throw new Exception("The DataSource does not contain
any data members to bind to.");
}
}
return null;
}
#endregion

#region public void BindControls(DataRow row)
public void BindControls(DataRow row)
{
bindControlsRecursive(this, row);
}
#endregion

#region public void BindControls(object datasource)
public void BindControls(object datasource)
{
bindControlsRecursive(this, datasource);
}
#endregion

#region public void ClearControls()
public void ClearControls()
{
clearControlsRecursive(this);
}
#endregion

#region public void UpdateFromControls(DataRow row)
public void UpdateFromControls(DataRow row)
{
updateFromControlsRecursive(this, row);
}
#endregion

#region public void UpdateFromControls(object datasource)
public void UpdateFromControls(object datasource)
{
updateFromControlsRecursive(this, datasource);
}
#endregion

#region public override void DataBind()
public override void DataBind()
{
IEnumerable dataSource = null;
base.OnDataBinding(EventArgs.Empty);
dataSource = GetDataSource();
if (dataSource != null)
{
PropertyDescriptor[] properties = null;
foreach (Control ctrl in this.Controls)
{
if (ctrl is IDataBound)
{
IDataBound idbc = (IDataBound)ctrl;
string boundField = idbc.BoundColumn;
if (boundField.Length > 0)
{
foreach (object dataItem in dataSource)
{
properties =
GetColumnPropertyDescriptors(dataItem);
for (int i = 0; i < properties.Length; i++)
{
PropertyDescriptor pd = properties[i];
if (boundField.CompareTo(pd.Name) == 0)
{
object ctlValue =
pd.GetValue(dataItem);
idbc.BoundValue =
pd.Converter.ConvertTo(ctlValue,
typeof(string));
}
}
if (idbc.SingleBind)
break;
}
}
}
}
}
}
#endregion

#region NESTED CLASSES
#region private sealed class PropertyDescriptorComparer :
IComparer
private sealed class PropertyDescriptorComparer : IComparer
{
public int Compare(object objectA, object objectB)
{
PropertyDescriptor pd1 = (PropertyDescriptor)objectA;
PropertyDescriptor pd2 = (PropertyDescriptor)objectB;
return String.Compare(pd1.Name, pd2.Name);
}
}
#endregion
#endregion
}
}

The property DataMember is the data member name with which the panel will be bonded. In our case it will be a table name from a data set.

The DataSource property is used to set or get the data source that will be involved in the binding process. We will use a data set filled from a NorthWind database. Our data set will contain one table that will be the data member. You can observe that the data source must inherit IList interface or IEnumerable interface else an exception will be throwed.

Let's take a look at GetDataSource() method. It return's a IEnumerable which is our data source object. As I mentioned early, in the data binding process we can use as a data source any object which implements IEnumerable. Because of this rule we have to check that our data source object type is IEnumerable (or IList which inherits from IEnumerable).

if (_datasource == null)
return null;

IEnumerable resolvedDataSource = _datasource as IEnumerable;

if (resolvedDataSource != null)
return resolvedDataSource;

IListSource listDataSource = _datasource as IListSource;

if (listDataSource != null)
{.....}

IListSource is nothing more than an interface that provides the functionality for an object to return a list that can be bonded to a data source. It also exposes ContainsListCollection property that indicates if the collection is a collection of IList objects.

IList listMember = listDataSource.GetList();

if (listDataSource.ContainsListCollection == false)
return (IEnumerable)listMember;

We set the value of listMember variable using GetList() method. After this, check to see if listDataSource object is a collection of IList objects. If it's not, then listMember must be of type IEnumerable, make a cast and exit from the method by returning it.

ITypedList typedListMember = listMember as ITypedList;

if (typedListMember != null)
{
PropertyDescriptorCollection propDescps =
typedListMember.GetItemProperties(null)
if ((propDescps != null) && (propDescps.Count != 0))
{
string dataMember = DataMember;

if (dataMember != null)
{
if (dataMember.Length == 0)
propertyMember = propDescps[0];
else
propertyMember = propDescps.Find(dataMember, true);

if (propertyMember != null)
{
object listRow = listMember[0];
object list = propertyMember.GetValue(listRow);

if (list is IEnumerable)
return (IEnumerable)list;
}
}

throw new Exception("A list that coresponds to the selected
DataMember can not be found.");
}

throw new Exception("The DataSource does not contains any data
members to bind to.");
}

If the data source is a collection of IList objects, get the schema of our bondable list object and save it in typedListMember. MSDN offers the following description for ITypedList "Provides functionality to discover the schema for a bondable list, where the properties available for binding differ from the public properties of the object to bind to". If there is such a schema, get the PropertyDescriptorCollection that represents the properties on each item used to bind data. We do this by using GetItemProperties() method that is exposed by typedListMember object. This method requires an array of PropertyDescriptor object as parameter, or you can pass a null reference. The PropertyDescriptor array is used to find the bondable objects from the collection. Now create a PropertyDescriptor object called propertyMember and initialize it with null. If propDescps collection is not null or it contains at least one item, then set the value for dataMember string from DataMember property. If dataMember is empty, we will get the first PropertyDescriptor object from propDescps collection. If it's not empty, then use Find(string name, bool ignoreCase) method which is exposed by propDescps. This method will return the PropertyDescriptor object with the specified name. The boolean parameter (ignoreCase) indicates whether to ignore the name case. After we have obtained the propertyMember, we will take the first object from listMember which will be passed as paramater to GetValue(object component) method exposed by propertyMember. This method will return the value of a property for the specified component. Now the last thing to do is to check if the returned value is of type IEnumerable, if it's not, throw and exception to notify you that the specified data member can not be found.

private PropertyDescriptor[]
GetColumnPropertyDescriptors(object dataItem)
{
ArrayList props = new ArrayList();
PropertyDescriptorCollection propDescps =
TypeDescriptor.GetProperties(dataItem);

foreach (PropertyDescriptor pd in propDescps)
{
Type propType = pd.PropertyType;
TypeConverter converter = TypeDescriptor.GetConverter(propType);

if ((converter != null) &&
converter.CanConvertTo(typeof(string)))
props.Add(pd);
}

props.Sort(new PropertyDescriptorComparer());
PropertyDescriptor[] columns = new PropertyDescriptor[props.Count];
props.CopyTo(columns, 0);

return columns;
}

In general, same explanation goes for GetColumnPropertyDescriptors(object dataItem) which returns a PropertyDescriptor array. We get the PropertyDescriptor that corresponds to each column, get the TypeConverter and check if the property type can be converted to string, add them to an array list and sort them using PropertyDescriptorComparer as parameter and finally insert them into the PropertyDescriptor array (columns).

Finally we have reached at the most known method involved in data binding process, DataBind(). Here is the code of this method :

public override void DataBind()
{
IEnumerable dataSource = null;

base.OnDataBinding(EventArgs.Empty);

dataSource = GetDataSource();

if (dataSource != null)
{
PropertyDescriptor[] properties = null;

foreach (Control ctrl in this.Controls)
{
if (ctrl is IDataBound)
{
IDataBound idbc = (IDataBound)ctrl;
string boundField = idbc.BoundColumn;

if (boundField.Length > 0)
{
foreach (object dataItem in dataSource)
{
properties = GetColumnPropertyDescriptors(dataItem);

for (int i = 0; i < properties.Length; i++)
{
PropertyDescriptor pd = properties[i];
if (boundField.CompareTo(pd.Name) == 0)
{
object ctlValue = pd.GetValue(dataItem);
idbc.BoundValue =
pd.Converter.ConvertTo(ctlValue,
typeof(string));
}
}

if (idbc.SingleBind)
break;
}
}
}
}
}
}

Here are the steps performed :

Call OnDataBinding(EventArgs e) method of the base class.
Get the data source that will be used in data binding.

dataSource = GetDataSource()

Iterate through the controls contained in this panel.

foreach (Control ctrl in this.Controls)

Check if current control implements IDataBound interface, if it does, cast it to it and get the BoundColumn property.

if (ctrl is IDataBound)
{
IDataBound idbc = (IDataBound)ctrl;
string boundField = idbc.BoundColumn;
}

Iterate through data source data item objects, get the properties for each data item object using GetColumnPropertyDescriptors method.

foreach (object dataItem in dataSource)
{
properties = GetColumnPropertyDescriptors(dataItem);
}

For each property, get the corresponding property descriptor, compare it's name with the BoundColumn value (boundField). If they match, get the value of the property descriptor, convert it to string and assign it to the current control BoundValue property.

for (int i = 0; i < properties.Length; i++)
{
PropertyDescriptor pd = properties[i];
if (boundField.CompareTo(pd.Name) == 0)
{
object ctlValue = pd.GetValue(dataItem);
idbc.BoundValue = pd.Converter.ConvertTo(ctlValue,
typeof(string));
}
}

These methods represent the back bone of our binding panel control. The BindingPanel control also contains other three important methods: bindControlsRecursive, updateFromControlsRecursive, clearControlsRecursive. I will start the presentation with bindControlsRecursive method.

private void bindControlsRecursive(Control control, object row)
{
foreach (Control ctrl in control.Controls)
{
if (ctrl is IDataBound)
{
IDataBound idbc = (IDataBound)ctrl;
string boundField = idbc.BoundColumn;

if (boundField != null && boundField.Length > 0)
{
if (row is DataRow)
idbc.BoundValue = ((DataRow)row)[boundField];
}
}
}
}

This method requires two parameters, a Control which is the container for the child controls that will be involved in the binding process, and the data object (row). The method iterates through all the child controls, checkbs if they implement IDataBound interface. If they do implement it, it gets the corresponding column value based on BoundColumn property and populates our control with data.

private void updateFromControlsRecursive(Control control, object row)
{
foreach (Control ctrl in control.Controls)
{
if (ctrl is IDataBound)
{
IDataBound idbc = (IDataBound)ctrl;
string boundField = idbc.BoundColumn;
object _old_value = null;

if (boundField.Length > 0)
{
if (row is DataRow)
_old_value = ((DataRow)row)[boundField];

if (_old_value != idbc.BoundValue)
{
if (row is DataRow)
{
if (idbc.BoundValue != null)
((DataRow)row)[boundField] = idbc.BoundValue;
else
((DataRow)row)[boundField] = DBNull.Value;
}
}

}
}
}
}

The method updateFromControlsRecursive performs same operations as bindControlsRecursive method but with the logic reversed. It iterates through all the child controls, checkbs if they implement IDataBound interface. If they do implement it, it gets the current control value and populates the corresponding column of the data object (row) based on BoundColumn property.

private void clearControlsRecursive(Control control)
{
foreach (Control ctrl in control.Controls)
{
if (ctrl is IDataBound)
{
IDataBound idbc = (IDataBound)ctrl;
string boundField = idbc.BoundColumn;

if (boundField != null && boundField.Length > 0)
idbc.BoundValue = DBNull.Value;
}
}
}

For cleaning up the controls values we use clear ControlsRecursive method. It simply iterates through all child controls, checkbs if they implement IDataBound interface. If they do implement it, clears their values (control value will be DBNull.Value).

Well, these are the most important things about this control.

Conclusion

As you can see, for the data binding process we have used reflection. The idea is simple; let's say for example that our custom text box control has the BoundColumn property value "ContactName" and the TableName property value "customers". After you set the DataMember and DataSource properties of BindingPanel, when DataBind() method is called, the panel will iterate thru it's child controls and for each child control will also iterate thru it's DataMember columns. When a match is found between BoundColumn property of the child control and a column name from the DataMember, the control's value will be updated with the value of the corresponding column. I want to make an observation, that in the example project I'm using only the first row from the DataMember, because the panel control is not iterating thru all DataMemberbs rows. If you want to iterate thru all rows, then use a repeater, make a template for it and include the custom panel in it.
If you want, you can extend all the functionality presented here. The zip file contains the entire project and also and usage example. As database I have used NorthWind, just change the connection string if required .

Web applications performance rules

2006-11-12T09:31:00.000-08:00

When you design and develop your web application you always must take in consideration the performance factor. By doing this you will remove the cost of rewriting modules, modifying code or redistributing the application. A good practice that must be kept in mind, for writing quality code, is to make frequent code reviews. For example, I often find a better implementation of a certain module after a code review. Also you should test different ways of implementing your code to determine the performance impact over your application.
Here are some rules that should be fallowed for writing high performing applications.

1. Store your content by using caching
As you know ASP.NET allow you to cache entire pages, fragment of pages or controls. You can cache also variable data by specifying the parameters that the data depends. By using caching you help ASP.NET engine to return data for repeated request for the same page much faster. There is one catch here, caching consumes server memory, so it’s not recommended to be used when you need to get updated data on your page.

2. Avoid session state
Whether you store your data in in-process or on state server or in a Sql Database, session state requires memory and it’s also time consuming when you sore or retrieve data from it. If you do not want to use session state, disable it on your web form using <@%Page EnableSessionState=”false”%> directive. In case you use the session state only to retrieve data from it and not to update it, make the session state read only by using <@%Page EnableSessionState =”ReadOnly”%> directive.

3. Avoid ViewSate
ViewState allow you to keep the content of a control across trips to server. This comes with a cost, a greater amount of data is sent from the server to client end vice versa, so the speed and network bandwidth can be affected. You can avoid this drawback by setting the EnableViewState property of your web controls to false, when you don’t need them to keep their state across server trips.

4. Use low cost authentication
Authentication can also have an impact over the performance of your application.
For example passport authentication is slower than form-base authentication which in here turn is slower than Windows authentication.

5. Use Server.Transfer() method for server side page redirection
It is better to use the Server.Transfer() method for server side aspx page redirection in the same application than Response.Redirect() method. This will reduce the extra roundtrip required by the second method (Response.Redirect()) to perform client side redirection.

6. The number of web server controls
The use of web server controls increases the response time of your application because they need time to be processed on the server side before they are rendered on the client side. Therefore take in consideration the usage of HTML elements where they are suited, for example if you want to display static text.

7. Avoid frequent usage of boxing and unboxing
When a value type such as a structure it is copied to a reference type such as a class, the compiler creates an object on the heap and copies the value of the value type from the stack to this newly created object on the heap. This process is called boxing and requires more overhead than just a simple from value type to value type. When you copy a reference type to a value type, the value of the object from the heap is copied to the value type from the stack. This process is called unboxing. You should take in consideration the overhead of these processes when you design your application.

8. Avoid using string for complex strings operations
The string type is immutable; this means that after a string is created it can’t be modified. When you modify a string the CRL creates a new one based on your modifications and returns it. The old string remains in memory until garbage collector will clean it. If your application is extensively modifying strings, then use the StringBuilder class. This class stores the string as an array of characters. The StringBuilder object is mutable and dose in-place modifications of strings.

9. Use AddRange() method with collections
There is a large number of collection classes that expose AddRange() method, which you can use to add an array of items to the collection instead of calling repeatedly Add() method inside a loop.

10. Avoid throwing exceptions
Throwing exceptions is a costly operation. You should be very careful when you throw exception from your application. Exceptions should be throwing only to signify exceptional error cases. You should never throw exceptions just for managing your application flow.

11. Avoid using unmanaged code
Calls to unmanaged code are a costly marshaling operation. Try to reduce the number calls between the managed and unmanaged code. Consider to do more work in each call rather than making frequent calls to do small tasks.

12. Avoid making frequent calls across processes
If you are working with distributed applications, this involves additional overhead negotiating network and application level protocols. In this case network speed can also be a bottleneck. Try to do as much work as possible in fewer calls over the network.

13. Make use of optimized managed providers
As you know OleDb is a generic provider which offers access to data exposed by any OleDb provider. Managed providers are specifically optimized for some databases. For example when you use OleDb to connect to a Sql server database, OleDb first passes your request to the OLE DB COM components which in turn translate the request to Sql Native Tabular Data Stream (TDS) format. If you will use SqlClient, this will directly construct the TDS packets and communicate with Sql server. The removal of extra translation will significantly improve the performance of your application.

14. Use stored procedure and not sql statements
When you are working with a RDBMS as Sql server you should use stored procedures rather than sql statements given as a text command, because stored procedure are highly optimized for server side data access.

15. Use DataReader instead of DataSet for forward-only sequential access
If you are reading a table sequentially you should use the DataReader rather than DataSet. DataReader object creates a read only stream of data that will increase your application performance because only one row is in memory at a time.

16. Use connection pooling
The slowest operation performed in a database application scenario is establishing a connection with a database. The Sql server .NET Data Provider offers connection pooling to improve performance when connecting to a Sql server database. In connection pooling old connection information is stored in a connection pool so it can be reused for the next connection. If you are using dynamic connection strings, you will disallow connection pooling mechanism because connections are only pooled on the exact connection string.

17. Use transactions
Distributed transactions might add performance overhead to your application, so you should use them only when required and keep their life as short as possible.