Shahed Khan (MVP)

ASP.NET MVC Tips: 301 Redirect non-www versions of URL to www.

Shahed Khan — Mon, 18 May 2009 15:02:21 GMT

Search Engine Optimization guides, recommends to have one version of a URL of the same content. Search engines may pickup www and non-www versions of URL as 2 separate URLs, i.e. http://xyz.com/page1 may be considered different to http://www.xyz.com/page1. It is a good idea to pick on of these URLs as preferred and use 301 redirects to send traffic from the other URLS to the preferred URL. Today we will pickup www version of URL as our preferred URL and look at how we can redirect the non-www version of the URL to our preferred URL structure using ASP.NET MVC.

We can achieve the above by writing a custom handler that extends from the MvcHandler. We are basically interested in the ProcessRequest method where we can get hold of the non-www version of the URL to replace it to the www. version of URL.

    public class The301GlobalHandler : MvcHandler
    {
        public The301GlobalHandler(RequestContext requestContext) : base(requestContext) { }

        protected override void ProcessRequest(HttpContextBase httpContext)
        {
            //We do not want this handler to process local requests
            if (httpContext.Request.IsLocal)
                base.ProcessRequest(httpContext);
            else
                ProcessExternalRequest(httpContext);
        }

        private void ProcessExternalRequest(HttpContextBase httpContext)
        {
            bool urlChanged = false;
            string url = RequestContext.HttpContext.Request.Url.AbsoluteUri;
            //Check for non-www version URL
            if (!RequestContext.HttpContext.Request.Url.AbsoluteUri.Contains("www"))
            {
                urlChanged = true;
                //change to www. version URL
                url = url.Replace("http://", "http://www.");                    
            }
            ProcessExternalRequest(url, urlChanged, httpContext);
        }

        private void ProcessExternalRequest(string url, bool urlChanged, HttpContextBase httpContext)
        {
            if (urlChanged)
            {
                //mark as 301
                httpContext.Response.Status = "301 Moved Permanently";
                httpContext.Response.StatusCode = 301;
                httpContext.Response.AppendHeader("Location", url);
            }
            else
                base.ProcessRequest(httpContext);
        }
    }

The above code is self explanatory, we are checking if the Request is local or external, we are only interested on external URLs. Next we check, whether the RequestContext.HttpCOntext.Request.Url.AbsoluteUri contains a "www" or not. If it do not contain a "www" we go and inject a "www" to the URL to convert the non-www version of URL to a www. version URL. Then we mark the previous response to a 301, which indicates that the previous URL has been permanently removed and all future requests should be directed to the given new URL.

We have developed our core handler above, however we need a wrapper IRouteHandler class to get the above The301GlobalHandler to work within the MVC Framework. This wrapper class is responsible to return an instance of the The301GlobalHandler.

    public class Route301GlobalHandler : IRouteHandler
    {
        public IHttpHandler GetHttpHandler(RequestContext requestContext)
        {
            return new The301GlobalHandler(requestContext);
        }
    }

We have got our Route301GlobalHandler ready, now we need all of our requests to go via this handler instead of the default. One easy way to do this, is to iterate through the route collection and assign them to this Route301GlobalHandler during the Application_Start().

    protected void Application_Start()
    {
        RegisterRoutes(RouteTable.Routes);
        Route301Global.ReAssignHandler(RouteTable.Routes);
    }

    public static class Route301Global
    {
        public static void ReAssignHandler(RouteCollection routes)
        {
            using (routes.GetReadLock())
            {
                AssignRoute301GlobalHandler(routes);
            }
        }

        private static void AssignRoute301GlobalHandler(IEnumerable<RouteBase> routes)
        {
            foreach (var routeBase in routes)
            {
                AssignRoute301GlobalHandler(routeBase);
            }
        }

        private static void AssignRoute301GlobalHandler(RouteBase routeBase)
        {
            var route = routeBase as Route;
            if (route == null) return;
            if (route.RouteHandler.GetType() != typeof(Route301Handler))
                route.RouteHandler = new Route301GlobalHandler();
        }
    }

Note, if you have other custom RouteHandler in your application, you will need to tweak this code, I am assuming all routes that will be mapped in the RegisterRoutes(RouteCollection routes) method uses the MvcHandler.

Conclusion

We have identified keeping one set of URL is important for SEO. Then we have looked at how we can 301 redirect non-www version of URL to www. version URL in ASP.NET MVC. Hope this saves you some time and thank you for being with me so far.

ASP.NET MVC Tips: Form POST, TryUpdateModel, unit test, Moq

Shahed Khan — Fri, 15 May 2009 14:10:58 GMT

Recently I have started playing with the Moq (pronounced "Mock-you" or just "Mock") a Mocking Library for .NET Developers, that takes full advantage of .NET 3.5 (i.e. Linq expression trees) and C# 3.0 features. Here in this post I will discuss how I have used the TryUpdateModel method in the Form POST scenario and also share how I have written a test case using Moq mocking library to deal with the TryUpdateModel<TModel>(TModel model) method of the ASP.NET MVC controller.

I have a very simple user interface, that allows user to enter data and submit, to add a new "User".

My View Page is:

and my "Action" is


You may have already noticed that I have decorated my action without any parameters, and my POST related codes are executed by checking the request type.

if (Request.RequestType == POST)
{
//code
}

As I have no parameters in my CreateUser(), I did not need to create separate action with AcceptVerbs("GET") and AcceptVert("POST") attribute. I have created an empty instance of MembershipCreateViewModel object and passed it to the TryUpdateModel() method to get the values of the posted form into my viewmodel object. MVC framework takes care of the rest and populates the viewModel with the desired values. Also note the RedirectToAction() method has been on success, it is very important to perform this client - redirect. It will ensure that the form does not resubmit, and the user will never see a prompt like this, if he hits the browser refresh button.



My MembershipCreateViewModel class is as follows,



I did not prefer passing four parameters to my CreateUser() Action such as,

[AcceptVerbs["POST"])
CreateUser(string username, string email, string password, string confirmPassword)
{
//code
}

instead I kept the method simple by using the MembershipCreateUserViewModel to communicated between the Controller and the View.

This is all good, but by now you may be wondering how would I test this Controller>Action. Lets explore that part. Here I will demonstrate my TestCase using the Moq framework, but you can do the same using other popular mocking frameworks like Rhino Mock, NMock, NMock2, NUnit.Mocks, EasyMock, TypeMock etc, or even with plain vanilla C# code. First of all I will need a FakeHttpContext to interact with my Controller from the test environment.

It is very straight forward to create a mock of a class or interface in Moq, I have created mocks of HttpContextBase, HttpRequestBase, HttpResponseBase, HttpSessionStateBase, HttpServerUtility above and decorated methods and properties that I use in my test cases using the Setup and SetupGet method that is available in the Moq library.

Note how easily with couple of lines of code I have a mockup of the HttpContextBase. The Mock<T> allows creation of custom value matchers that can be used on setups and verification, completely replacing the built-in It class with our own argument matching rules.

var httpContext = new Mock<HttpContextBase>();
var request = new Mock<HttpRequestBase>
httpContext.Setup(ctx => ctx.Request(request.Object);

This above code snippet is creating mock instances of HttpContexBase and HttpRequestBase classes, and then also setting up that httpContext.Request will return the mock instance "request".

Now lets look at how I have used this mock httpContext in a test case.

I have created a test case here that tests our CreateUser() action. Note I have created an instance of the ControllerContext and passed the httpContext mock object as a parameter of its constructor. After that I have assigned this instance ( context ) to the controller.ControllerContext property.

The Mock.Get() method is interesting it can retrieve a mock object for the given object instance. Here I have retrieved the request object and have modified it further. I have setup so that the request.Form returns NameValueCollection. You may be wondering why did I pass NamValueCollection. You may recall that I have used the TryUpdateModel() method in my action to get the form values into our viewmodel, and if you look what is happening under the hood of TryUpdateModel() method you will find that, "Form" is of type System.Collections.Specialized.NameValueCollection and a member of System.Web.HttpRequestBase, and

the internals of TryUpdateModel() iterates through each item of the ContollerContext.HttpContext.Request.Form object and populates the matching properties of the viewmodel using reflection. The above code snippet from the ValueProviderDictionary class where we see that the keys are being read from the Form object to populate a dictionary.

Conclusion

Here in this post I have discussed a Form POST scenario and I have decorated my action method without any parameters as by default TryUpdateModel method looks at the submitted Form object and attempt to assign it to the viewmodel object that we pass. I have also demonstrated how I have used the Moq library to create fake/mock objects for my testcases, how I have setup some fake methods and properties. I have also demonstrated the handy Mock.Get method that can retrieve a mock object from a given object instance and allows us to modify the mock object further. Thank you for being with me so far and I hope this helps.

ASP.NET MVC tips: Routing Engine to aid SEO / 301 Redirect / Tracking

Shahed Khan — Fri, 13 Feb 2009 19:06:00 GMT

Routing Library resides in the System.Web.Routing Namespace of the .NET Framework 3.5, which provides us the flexibility to use URLs that has no mapping to a physical file. This means ASP.NET MVC framework provides flexible URL mapping engine and enables us to write SEO (Search Engine Optimization) friendly URLs with very little effort. No one can deny the importance of SEO, to be successful in search based marketing. What better way to analyze a business than from what customers are looking for on the Internet through keyword research. SEO is the way to go.

SEO friendly URL Format for an e-commerce application may be
/Products/List/ProductCategory
/Products/Detail/ProductName

URL Example
/Products/List/CareCare
/Products/Detail/MiracleCarDuster

In ASP.NET MVC world the URL Routing System maps the incoming URLs to the relevant Controller and Action, in the above example our Contoller is Products and Action is List or Detail. We normally go and define a Route object and add it to the RouteCollection and register the RouteCollection during Application_Start(). Out of the box System.Web.Mvc library ships with the RouteCollectionExtensions which allows us to define routes easily using the the different overloads of MapRoute method.

Example:

public static void RegisterRoutes(RouteCollection routes)
{
routes.IgnoreRoute("{resource}.axd/{*pathInfo}");

           routes.MapRoute(
                "Default",                                              // Route name
                "{controller}/{action}/{id}",                           // URL with parameters
                new { controller = "Home", action = "Index", id = "" } // Parameter defaults
            );

}

If you look under the hood you will find, a Route object is created and added to the RouteCollection.

Route route = new Route(url, new MvcRouteHandler()){};
.....
.....
routes.Add(name, route);

note that "MvcRouteHandler" have been passed as a parameter by default, when we use the routes.MapRoute() method. The overloads of MapRoute() extension methods are just helper methods to make things easy for us, it is not mandatory that we will have to always use this. We can define a Route object in plain .NET code and assign necessary properties to it, we can also pass our preferred IRouteHandler. This gives superb flexibility with handling URLs. For instance In a practical world of web marketing / search marketing we always need to support Legacy URLs. In the web marketing world ad hoc campaigns are launched, and what may have worked last week may not work this week any more, as a result the URL structure changes frequently and we face the need to start redirecting to the new URLs.

On Top of that during this transformation of URLs we need to implement "301 Moved Permanently" redirections, which means the previous URL has been permanently removed and all future requests should be directed to the given new URI. Handling this scenario has become very easy with the Routing Engine. All we need to do is add a new Route or modify the existing Route to fit our need. Matt Hawley has an excellent post on Legacy Url Routing which describes how to route existing aspx file based URLs to the appropriate MVC Controller and Action. This article also gives directions on how to implement custom Route and custom RouteHandler.

public static void RegisterRoutes(RouteCollection routes)
{
routes.IgnoreRoute("{resource}.axd/{*pathInfo}");

           routes.MapRoute(
                "Default",                                              // Route name
                "{controller}/{action}/{id}",                           // URL with parameters
                new { controller = "Home", action = "Index", id = "" } // Parameter defaults
            );

routes.Add("", new LegacyRoute(
    "Users/Login.aspx",
    "Login",
    new LegacyRouteHandler())); // Defined a Custom Route class and have passed a custom IRouteHandler.

}

As you can see in the above code, how easily we can add a custom route and pass a custom IRouteHandler (in this case LegacyHandler).

Tracking - is another common task performed, we want to track everything, every single clicks a consumer performs on the site. This has also becomes easy in the world of ASP.NET MVC. By design we define separate actions for each functionality and we Route to the Controller - Action to get anything done. So tracking would be a viable option to do centrally just before creating the Controller object or just before delegating to the Action.

You will notice the implementation of IRouteHandler requires to implement only one method "GetHttpHandler" which returns a IHttpHandler

public interface IRouteHandler
{
IHttpHandler GetHttpHandler(RequestContext requestContext);
}

You will find the MvcRouteHandler implements IRouteHandler like this

public class MvcRouteHandler : IRouteHandler {
        protected virtual IHttpHandler GetHttpHandler(RequestContext requestContext) {
            return new MvcHandler(requestContext);
        }

}

The real delegation of a Route to a Controller and Action happens in the ProcessRequest(HttpContext context); method of the MVCHandler class which is the implementation of IHttpHandler. The ProcessRequest(HttpContext contxt) method may be a be a good place to centrally control tracking in one of our custom Handlers. The implementaiton of MVCHandler is as follows, where you can see how a controller is created by the IControllerFactory factory, and then Execute() method is called. We can do our tracking somewhere before calling the Execute() method.

protected internal virtual void ProcessRequest(HttpContextBase httpContext) {
AddVersionHeader(httpContext);

// Get the controller type
string controllerName = RequestContext.RouteData.GetRequiredString("controller");

            // Instantiate the controller and call Execute
            IControllerFactory factory = ControllerBuilder.GetControllerFactory();
            IController controller = factory.CreateController(RequestContext, controllerName);
            if (controller == null) {
                throw new InvalidOperationException(
                    String.Format(
                        CultureInfo.CurrentUICulture,
                        MvcResources.ControllerBuilder_FactoryReturnedNull,
                        factory.GetType(),
                        controllerName));
            }
            try {
                controller.Execute(RequestContext);
            }
            finally {
                factory.ReleaseController(controller);
            }
        }

Did you know, Routes in the ASP.NET Mvc are matched and executed on a first match bases! It may be important to order the routes so that the correct pattern is matched first before a more general pattern matches and executes it. It is sometimes hard to figure out which particular pattern will be caught first when we have a lot of routes, ASP.NET Routing Debugger comes in to rescue, Phil Hack has put together this nice little route tester utility which can save a lot of time. This utility quickly displays in Red and Green color what Route patterns have matched for a particular URL. So we can type in various URLs in the addressbar to see which routes matches.

Lets now looks at a different problem, we normally define all the routes in the global.aspx.cs file, this causes a problem when Routes changes frequently, every single time a new route is added or an existing one is modified we need to recompile web application and upload the new dll to the server, again it is not mandatory to write Routing rules in the global.aspx.cs file, we can easily store the routing rules to a Xml file and use a combination XML related .NET libraries and .NET Reflection APIs to read from the Xml file and create/deserialize Route Objects to add them to the RouteCollection during the Application_Start(). But still we haven't overcome the limitations of restarting the application as the RouteCollection gettting registered during Application_Start. I think we have to live with that, unless we go and implement some kind of FileSystemWatcher to monitor the Xml file and force to refresh the RouteTable.Routes object when the xml file changes. I haven't tried implementing this yet but this would work I think.

We have discussed here, how ASP.NET Routing engine eases writing SEO friendly Url, maitaining Url redirections and tracking centrally. Hope this helps.

Thank you for being with me so far.

ASP.NET tips: Display resultset from Multiple DataTable

Shahed Khan — Tue, 10 Feb 2009 18:06:19 GMT

I normally do not use DataSet and prefer Objects instead generated by the ORM frameworks, but recently I had to produce a ASP.NET page that displayed a list of records from multiple DataTables. Lets look at a similar example.

Lets assume we consume this DataSet which has two DataTables "Agent" and "RealEstateProperty". The task is to display, what properties belongs to which agent, in a GridView.

There are different ways to accomplish this task, lets look at them one by one.

Method 1: Bind DataTables to a single GridView

To bind these multiple DataTables to a single GridView control, we can quickly create a new temporary DataTable, with the required fields and populate the Rows and then bind the new DataTable Rows to the GridView.

The above code is self explanatory, where I have created a temporary DataTable, populated its rows by iterating through the original DataTables and then binded the Grid to the new DataTable.Rows. The interesting piece of code to note here is the row.GetChildRows(), which respects the relationship and automatically returns the related child rows. The aspx part looks like the following, where we have a GridView with three columns.

and the RowDataBound code is

Method 2: Bind DataTables to a nested GridView

If we want to avoid creating temporary dummy DataTable as described in method 1, we can use the technique of nested list control. Now we can do this by using

two GridView, or
two DataList, or
two Repeaters or
a combination of Repeater and GridView, or
a combination of Repeater and DataList, or
a combination of GridView and DataList.

We are going to look at a combination of 2 GridViews here, where one GridView is nested inside another, you can do any of the above combinations. For this case the the aspx code is,

Notice the parent and nested GridViews has different onrowdatabound methods. In this technique the parent grid is binded to the the Agent DataTable Rows and the nested GridView is binded to the child RealEstateProperty DataTable Rows. Here is the code.

Method 3: Convert the DataSet to Objects and then bind to GridView

We can generate csharp class from the dataset schema using Xsd.exe and then bind the GridViews to the objects. I have discussed similar technique in one of my previous blog post, where you will find how we can use the Xsd.exe that ships with the .NET Framework.

Example
    C:\temp>xsd propertyDataSet.xsd /l:cs /c
    Microsoft (R) Xml Schemas/DataTypes support utility
    [Microsoft (R) .NET Framework, Version 2.0.50727.42]
    Copyright (C) Microsoft Corporation. All rights reserved.
    Writing file 'C:\temp\propertydatasetclass.cs'.

I also demonstrated a handy DataTableToT() method to assist in converting DataTable to strongly typed object. And when we have the DataTable converted to a stronglytyped object/list/collection it is very easy to bind to the bind to the GridView.

Other Tips
1. DataSet also comes with handy Merge Method, check here, we could have also used this method.
2. When we load a DataSet from xml schema if we do not provide the strongly typed DataSet it will not preserve the Relationship automatically.

Note: The Relations Count = 0;

3. To preserve Relations automatically during a DataSet load from xml, provide strongly typed DataSet. Both of the following methods will automatically preserve the parent child relationship. Also even if you consume them from a webservice client application they will preserve the Relations.

4. DataSet.WriteXml() method serializes the DataSet content and writes XML data.
5. DataSet.WriteXmlSchema() method writes the DataSet structure as XML Schema (xsd file).

Conclusion
We have discussed different techniques to bind multiple DataTables to GridView, we have also discussed some handy tips about the DataSet. Hope this helps.

ASP.NET tips: CustomBase class with Generic Class

Shahed Khan — Sun, 11 Jan 2009 05:34:16 GMT

All our ASP.NET pages must derive from System.Web.UI.Page class, but we can take the advantage of inheritance and create a Custom Base Class to manage Security, Session, Error Handling and other repetitive custom codes elegantly. We normally go and create a custom base class that derives from System.Web.UI.Page class which looks something like this.

Then we go and inherit our ASP.NET pages from this class. Note: For ASP.NET 2.0 website projects this file needs to be in a separate class library because of its dynamic compilation mechanism. Our ASP.NET page may look like this.

This is good but, we also have the flexibility to use generic classes and enjoy the benefits of generic classes in our ASP.NET pages and do not need to worry about type casting to and from the universal base type Object, moreover the lack of compile time checking in our pages may sometimes lead to some grief, that we can avoid easily.

Lets look at how we can extend our BasePage using Generic Class. Lets create a an ExtendedBasePage.

In the above code we have declared a type parameter T in the angle brackets, which must derive from RealEstateProperty class, and our ExtendedBasePage derives from our previous Basepage. Then we have used T as return type of property "Property". You may be wondering by now where did RealEstateProperty class came from.

Here you can see Land and Apartment derives from RealEstateProperty class, these are all business objects of my fictitious realestate website and I want to access the "this.Property" object from my pages. Lets now create a ASP.NET page that derives from ExtendedBasePage<T>.

Here in this ASP.NET page that derives from ExtendedBasePage<Land> I have passed the "Land" as the type parameter, now this.Property is type safe, we cannot go and write this.Property = new Apartment(), the compiler will throw an exception straightway "Cannot implicitly convert type 'Website.Util.Apartment' to 'Website.Util.Land'". Also notice we do not need to type cast this.Property object to Land to be able to access its public properties.

Here we discussed how we can take advantage of Generic Classes in our ASP.NET custom base pages, hope this helps thank you for being with me so far.

ASP.NET tips: CustomBase class with Generic Class

Shahed Khan — Sun, 11 Jan 2009 05:16:07 GMT

This is good but, we also have the flexibility to use generic classes and enjoy the benefits of generic classes in our ASP.NET pages and do not need to worry about type casting to and from the universal base type Object, moreover the lack of compile time checking in our pages may sometimes lead to some grief.

Lets look at how we can extend our BasePage using Generic Class. Lets create a an ExtendedBasePage.

In the above code we have declared a type parameter T in the angle brackets, which must derive from RealEstateProperty class, and our ExtendedBasePage derives from our previous Basepage. Then we have used T as return type of property "Property". You may be wondering by now where did RealEstateProperty class came from.

Here we discussed how we can take advantage of Generic Classes in our ASP.NET custom base pages, hope this helps thank you for being with me so far.

ADO.NET Data Services Framework (former - astoria)

Shahed Khan — Thu, 11 Dec 2008 03:40:33 GMT

ADO.NET Data Services enable applications to expose data as a data service to be consumable via web clients. The data service which can be easily accessible via regular HTTP requests. CRUD operations are performed using HTTP verbs - GET, POST, PUT and DELETE. The data service responses open formats such as JSON and Aop/APP which are idal back-ead for AJAX-style applications, Rick Interactive Applications and other web clients. ADO.NET client libraries and developer tools works with both on premises services created using ADO.NET Data Services and also with hosted CLOUD services.

Some useful links

Data Platform Developer Center - Data Services page

Data services conceptual documentation on MSDN

Data services API reference documentation on MSDN

Data services team blog

Data services online forum (a place to ask us your data services related questions)

Whitepaper: Using ADO.NET Data Services V1
Technical Articles

Overview: ADO.NET Data Services
The ADO.NET Data Services framework consists of a combination of patterns and libraries that enable the creation and consumption of data services for the web. This article will discuss the key elements of the ADO.NET Data Services framework at a high level and the motivation behind its design.

Using ADO.NET Data Services
Learn how to create and use ADO.NET Data Services, and get documentation on the various details around the URI and payload formats.

Expose and Consume Data in a Web Services World
What is a data service? The ADO.NET Data Services framework consists of a combination of patterns and libraries that enable the creation and consumption of data services for the web. This article will discuss exposing and consuming data using Data Services, describing data with the Entity Data Model, and securing your service.

MSDN Reference Documentation

MSDN API Reference Documentation – Server
MSDN API Reference Documentation – Client

ADO.NET Data Services (Silverlight)

Data Services Futures

Offline-Enabled Data Services and Desktop Applications
Learn how to create offline-capable applications that have a local replica of their data, how to synchronize that replica with an online data service when a network connection becomes available, and how replicas can be used with the ADO.NET Entity Framework.

Transparent Design Process

Design Notes
See the teams feature design notes online and give your comments on the design.

How Do I …

Deep Dive Videos

Developing Applications Using Data Services
See how to use common libraries and tools when building applications using on premises and/or cloud services (Windows Azure services, SQL Data Services, etc.).

Programming Windows Azure Tables Using Data Services Client Libraries and Tools
Learn how to use the highly scalable, available and durable Windows Azure table storage service. This session presents a deep dive with demos (using ADO.NET Data Services clients & interaction conventions) showing in detail how to work with cloud storage.

Microsoft Chart Controls for ASP.NET and Windows Forms

Shahed Khan — Tue, 02 Dec 2008 01:35:52 GMT

Now Microsoft Chart controls Add-on for Microsoft Visual Studio 2008 can be used for charting needs.

Prerequisite: Microsoft Visual Studio 2008 SP1 and Microsoft Chart Controls for Microsoft .NET Framework 3.5.

For sample Environment for Microsoft Chart Controls check here. The sample environment contains over 200 samples for both ASP.NET and Windows Forms.

See the following related links:

There are lots of third party Chart Controls available for ASP.NET as well, please check here.

Reflection Tips on Nested Classes: Use (+) plus instead of (.) dot with Assembly.GetType

Shahed Khan — Fri, 07 Nov 2008 08:23:40 GMT

Lets say we want to use reflection to generate a mock test case for this following Nested Class ClientAddress.

When we load an assembly from a disk dynamically, we can use GetType to look up a type defined in the assembly.

Example:

Assembly assembly = Assembly.GetAssembly(typeof(TheClient));
Type type = assembly.GetType("ConsoleApplicationUsePlus.TheClient");
object obj = Activator.CreateInstance(type);

But one point to remember here, to get Assembly.GeType working with nested classes a Plus(+) sign should precede the nested class. To get a parent class and a nested class we have to use

Type.GetType("ParentClass+NestedClass") //Notice the Plus(+) sign.

So in the above example to get ClientAddress we would have to write something like this.

Assembly assembly = Assembly.GetAssembly(typeof(TheClient));
Type type = assembly.GetType("ConsoleApplicationUsePlus.TheClient+ClientAddress"); //Notice the Plus(+) sign.
object obj = Activator.CreateInstance(type);

This is well documented in MSDN and here is the full chart
http://msdn.microsoft.com/en-us/library/aa332510.aspx

To Get An unmanaged pointer to MyType
Use Type.GetType("MyType*")

To Get An unmanaged pointer to a pointer to MyType
Use Type.GetType("MyType**")

To Get A managed pointer or reference to MyType
Use Type.GetType("MyType&"). Note that unlike pointers, references are limited to one level.

To Get A parent class and a nested class
Use Type.GetType("MyParentClass+MyNestedClass")

To Get A one-dimensional array with a lower bound of 0
Use Type.GetType("MyArray[]")

To Get A one-dimensional array with an unknown lower bound
Use Type.GetType("MyArray[*]")

To Get An n-dimensional array
Use A comma (,) inside the brackets a total of n-1 times. For example,System.Object[,,] represents a three-dimensional Object array.

To Get A two-dimensional array's array
Use Type.GetType("MyArray[][]")

To Get A rectangular two-dimensional array with unknown lower bounds
Use Type.GetType("MyArray[*,*]") or Type.GetType("MyArray[,]")

Lets go back to generate our mock test case for the Nested class ClientAddress.

namespace ConsoleApplicationUsePlus
{
    class Program
    {
        static void Main(string[] args)
        {
            MockHelper generator = new MockHelper();
            //Generate mock testcase
          generator.Generate();
            Console.ReadLine();
        }
    }

    class MockHelper
    {
        int index = 0;

        private void GenerateMock(object obj)
        {
            DoWork(obj, string.Empty);
        }

Dictionary<string, string> keys = new Dictionary<string, string>();

        private void DoWork(object obj, string baseInstanceName)
        {
            Console.WriteLine(obj.GetType().ToString());
            index = index + 1;

string instanceName = string.Format("{0}{1}", obj.GetType().Name, index);
Console.WriteLine(String.Format("{0} {1} = new {0}(); ", obj.GetType().Name, instanceName));

keys.Add(baseInstanceName, instanceName);

            foreach (System.Reflection.PropertyInfo property in obj.GetType().GetProperties())
            {
                if (property.PropertyType.Assembly.FullName.Contains("ConsoleApplicationUsePlus"))
                {

                    object propertyInstance = property.GetValue(obj, null);
                    if (propertyInstance == null)
                    {
                        propertyInstance = Activator.CreateInstance(property.PropertyType);
                        if (property.CanWrite)
                            property.SetValue(obj, propertyInstance, null);

string baseI = String.Format(@"{0}.{1}", instanceName, property.Name);
DoWork(propertyInstance, baseI);

                        Console.WriteLine(String.Format(@"{0}.{1} = {2} ;", instanceName, property.Name, keys[baseI]));
                    }
                }
                else if (property.PropertyType == typeof(string))
                {
                    Console.WriteLine(String.Format(@"{0}.{1} = {2} ;", instanceName, property.Name, GetRandomString()));
                }
            }
        }

        //Entry point
        public void Generate()
        {

            Assembly assembly = Assembly.GetAssembly(typeof(TheClient));
            Type type = assembly.GetType("ConsoleApplicationUsePlus.TheClient+ClientAddress"); //Notice the plus sign(+)
            object obj = Activator.CreateInstance(type);

GenerateMock(obj);

}

        private string GetRandomString()
        {
            long i = 1;
            foreach (byte b in Guid.NewGuid().ToByteArray())
            {
                i *= ((int)b + 1);
            }
            return string.Format("{0:x}", i - DateTime.Now.Ticks);
        }

}
}

and the output looks like the following.

I have discussed about the MockHelper in one of my earlier post, so not discussing this code again here.

Conclusion

We have looked at the qualified type name of nested classes, also looked at how to use Type.GetType() for various types. The best way to avoid any mistakes on the type name possibly, is to create and instance of the class and to invoke the GetType().ToString() on the instantiated object;

Example :

TheClient.ClientAddress obj = new TheClient.ClientAddress();

Console.WriteLine(obj.GetType().ToString());

Enjoy Coding!!

ASP.NET Tips: DropDownList.ClearSelection() to avoid "Cannot have multiple items selected in DropDownList"

Shahed Khan — Sat, 23 Aug 2008 06:50:13 GMT

Problem
I was facing the following Exception when I was programmatically assigning Selected Value of a DropDownList with the following piece of code.

ListItem item = DropDownListTest.Items.FindByValue("Test");
if (item != null)
item.Selected = true;

Exception

Cannot have multiple items selected in a DropDownList.

Description: An unhandled exception occurred during the execution of the current web request. Please review the stack trace for more information about the error and where it originated in the code.
Exception Details: System.Web.HttpException: Cannot have multiple items selected in a DropDownList.
Source Error:

An unhandled exception was generated during the execution of the current web request. Information regarding the origin and location of the exception can be identified using the exception stack trace below.

Stack Trace:

[HttpException (0x80004005): Cannot have multiple items selected in a DropDownList.]
   System.Web.UI.WebControls.DropDownList.VerifyMultiSelect() +107
   System.Web.UI.WebControls.ListControl.RenderContents(HtmlTextWriter writer) +1825978
   System.Web.UI.WebControls.WebControl.Render(HtmlTextWriter writer) +29
   System.Web.UI.Control.RenderControlInternal(HtmlTextWriter writer, ControlAdapter adapter) +25
   System.Web.UI.Control.RenderControl(HtmlTextWriter writer, ControlAdapter adapter) +121
   System.Web.UI.Control.RenderControl(HtmlTextWriter writer) +22
   System.Web.UI.Control.RenderChildrenInternal(HtmlTextWriter writer, ICollection children) +199
   System.Web.UI.Control.RenderChildren(HtmlTextWriter writer) +20
   System.Web.UI.Control.Render(HtmlTextWriter writer) +7
   System.Web.UI.Control.RenderControlInternal(HtmlTextWriter writer, ControlAdapter adapter) +25
   System.Web.UI.Control.RenderControl(HtmlTextWriter writer, ControlAdapter adapter) +121
   System.Web.UI.Control.RenderControl(HtmlTextWriter writer) +22
   CSSFriendly.WizardAdapter.RenderStep(HtmlTextWriter writer, Wizard wizard) +137
   CSSFriendly.WizardAdapter.RenderContents(HtmlTextWriter writer) +93
   System.Web.UI.WebControls.Adapters.WebControlAdapter.Render(HtmlTextWriter writer) +23
   System.Web.UI.Control.RenderControlInternal(HtmlTextWriter writer, ControlAdapter adapter) +2116097
   System.Web.UI.Control.RenderControl(HtmlTextWriter writer, ControlAdapter adapter) +121
   System.Web.UI.Control.RenderControl(HtmlTextWriter writer) +22
   System.Web.UI.Control.RenderChildrenInternal(HtmlTextWriter writer, ICollection children) +199
   System.Web.UI.Control.RenderChildren(HtmlTextWriter writer) +20
   System.Web.UI.Control.Render(HtmlTextWriter writer) +7
   System.Web.UI.Control.RenderControlInternal(HtmlTextWriter writer, ControlAdapter adapter) +25
   System.Web.UI.Control.RenderControl(HtmlTextWriter writer, ControlAdapter adapter) +121
   System.Web.UI.Control.RenderControl(HtmlTextWriter writer) +22
   System.Web.UI.Control.RenderChildrenInternal(HtmlTextWriter writer, ICollection children) +199
   System.Web.UI.Control.RenderChildren(HtmlTextWriter writer) +20
   System.Web.UI.UpdatePanel.RenderChildren(HtmlTextWriter writer) +236

Solution

The solution is to remember to call ClearSelection() Method before calling FindByValue("") or FindByText("") Method.

The following piece of code will work fine.

DropDownListTest.ClearSelection();

ListItem item = DropDownListTest.Items.FindByValue("Test");
if (item != null)
item.Selected = true;

I also noticed, I do not get the "Cannot have multiple items" exception when I use SelectedIndex instead. i.e.

DropDownListTest.SelectedIndex = 12;

Hope this saves some of your time. Happy Coding.

Reflection Tips: Generate Mock objects for Test Cases.

Shahed Khan — Tue, 05 Aug 2008 14:20:50 GMT

Filling up Mock objects with random data is possibly one of the most time consuming and boring chapter of writing test cases. Let say we have the following classes and we want to write some mock objects.

Mock Object Code Example

       private Client GetMockClient()
        {
            Client Client1 = new Client();
            Client1.FirstName = "Random String 6dc22d70-ad0c-4552-9c86-2925e723a326";
            Client1.LastName = "Random String 3e08dc98-495a-4a70-bff4-b7b21489b0d0";

ClientAddress ClientAddress2 = new ClientAddress();

            ContactAddress ContactAddress3 = new ContactAddress();
            ContactAddress3.Address = "Random String e5957034-893b-4d2c-a29a-5b23e2561c00";
            ContactAddress3.Phone = "Random String 8d034e87-ece3-42b8-ae97-35fad1639f41";
            ContactAddress3.Mobile = "Random String 73a6abad-3268-4ae4-b01c-1732ab0f5f52";
            ClientAddress2.HomeAddress = ContactAddress3;

            ContactAddress ContactAddress4 = new ContactAddress();
            ContactAddress4.Address = "Random String 117ef00d-f29d-4697-97ae-123a6b56da4f";
            ContactAddress4.Phone = "Random String 8e4d0bbe-f470-4438-8940-06d9889e3943";
            ContactAddress4.Mobile = "Random String 6f0cba5c-5a88-4e5b-88ae-32a569cffa41";
            ClientAddress2.ShippingAddress = ContactAddress4;

Client1.ClientAddress = ClientAddress2;

            Misc Misc5 = new Misc();
            Misc5.OrderDate = DateTime.Now;
            Misc5.Quaitity = 945515547;
            Misc5.DeliveryDate = DateTime.Now;

Customer Customer6 = new Customer();

            CustomerDemographics CustomerDemographics7 = new CustomerDemographics();
            CustomerDemographics7.FirstName = "Random String 9b9542e6-2eb9-4ac8-bbd9-46272c8531b4";
            CustomerDemographics7.LastName = "Random String 275ca427-9373-41a7-8249-9a3fd94631bd";

            ContactAddress ContactAddress8 = new ContactAddress();
            ContactAddress8.Address = "Random String c9d18341-cb7e-4086-ba09-76fd7eb09f71";
            ContactAddress8.Phone = "Random String d88849f2-f443-46b1-9d21-3eaed1739696";
            ContactAddress8.Mobile = "Random String 984cfe2b-c35e-46f4-8eb1-27342d3e21b2";
            CustomerDemographics7.HomeAddress = ContactAddress8;

            ContactAddress ContactAddress9 = new ContactAddress();
            ContactAddress9.Address = "Random String e67ae73f-8edd-47d1-add0-b1e84ddb6b05";
            ContactAddress9.Phone = "Random String 91b8d44e-3718-4cc7-be8a-194d308b8969";
            ContactAddress9.Mobile = "Random String a0d19e07-2b80-4f7a-acd2-7a507455c000";
            CustomerDemographics7.ShippingAddress = ContactAddress9;

Customer6.CustomerDemographics = CustomerDemographics7;

Misc5.AlternativeCustomer1 = Customer6;

Client1.Misc = Misc5;

return Client1;

}

As you can see we will need to spare significant amount of time to prepare a Mock object for "Client" class. But you will be happy to know that I did not write a single line of the code that I pasted above. Yes, I generated it using Reflection. Let me share that magical piece of code with you which can save you a heaps of time.

The Mock Helper

    public class MockHelper
    {
        public MockHelper()
        {
            this.MaxDepth = 100;
        }

int index = 1;

        Dictionary<string, string> keys = new Dictionary<string, string>();
        List<string> assemblyList = new List<string>();
        StringBuilder codeBuilder = null;

        public int MaxIndexValue { get; set; }
        public string Generate(object obj)
        {
            //Assembly List that we are interested in for recursive calls, add according to your need.
            assemblyList.Add("SmartDataManagement.Blog");

            codeBuilder = new StringBuilder();
            GenerateCode(obj, string.Empty);
            return codeBuilder.ToString();
        }

        private void GenerateCode(object obj, string theKey)
        {
            string instanceName = string.Format("{0}{1}", obj.GetType().Name, index);
            codeBuilder.AppendLine(String.Format("{0} {1} = new {0}();", obj.GetType().Name, instanceName));
            keys.Add(theKey, instanceName);
            //Iterate through the list of Public Properties of the object instance
            foreach (System.Reflection.PropertyInfo property in obj.GetType().GetProperties())
            {
                //Decide to dig deeper, if a PropertyType belongs to the assemblies that we are interested in, we go deep.
                if (GoDeeper(property))
                {
                    index = index + 1;
                    //Avoid infinite Loop situation
                    if (index < this.MaxIndexValue)
                    {
                        object propertyInstance = property.GetValue(obj, null);
                        if (propertyInstance == null)
                        {
                            //Dynamically create Property Instance
                            propertyInstance = Activator.CreateInstance(property.PropertyType);
                            if (property.CanWrite)
                                property.SetValue(obj, propertyInstance, null);
                            string key = Guid.NewGuid().ToString();
                            codeBuilder.AppendLine();
                            //Recursive call
                            GenerateCode(propertyInstance, key);

                            codeBuilder.AppendLine(String.Format(@"{0}.{1} = {2};", instanceName, property.Name, keys[key]));
                            codeBuilder.AppendLine();
                        }
                    }
                }
                else if (property.PropertyType == typeof(string))
                {
                    codeBuilder.AppendLine(String.Format(@"{0}.{1} = ""{2}"";", instanceName, property.Name, GetRandomString()));
                }
                else if (property.PropertyType == typeof(DateTime))
                {
                    codeBuilder.AppendLine(String.Format(@"{0}.{1} = DateTime.Now;", instanceName, property.Name));
                }
                else if (property.PropertyType == typeof(int))
                {
                    codeBuilder.AppendLine(String.Format(@"{0}.{1} = {2};", instanceName, property.Name, GetRandomInt()));
                }
            }
        }

        private bool GoDeeper(PropertyInfo property)
        {
            //Dig deeper for interested Assemblies only, Please feel free to extend and put complex logics to serve your purpose.
            foreach (string assemblyName in assemblyList)
            {
                if (property.PropertyType.Assembly.FullName.Contains(assemblyName))
                    return true;
            }
            return false;
        }

        private string GetRandomString()
        {
            return String.Format("Random String {0}", Guid.NewGuid().ToString());
        }

        private int GetRandomInt()
        {
            byte[] buffer = Guid.NewGuid().ToByteArray();
            return BitConverter.ToInt32(buffer, 0);
        }
    }

The above code is self explanatory, I also commented to give an idea of how this is working, In short, I take an instance of the desired class, iterate through all of its Properties using Reflection and generate desired piece of code. While iterating, I also create property instance as required and loop thorough the properties of the child in a recursive manner until all of them are served. The assemblyList object maintains the list of the assemblies that we are interested in for recursion. Its worth mentioning the above piece of code has limitations, it will not work in the cases where there are circular references of Types for properties, that is why I kept a check for MaxIndexValue to break the infinite loop scenario.

Fig, shows an example of circular references of Types, here Client has Misc property (of Type: Misc), and Misc has AlternativeClient1 property (of Type: Client).

The MockHelper has very simple logic to decide to create dynamic instances and to do recursive calls, it will get stuck within Client and Misc for this example. We can definitely overcome this by putting more complex logics and checks. I wanted to keep it simple and moreover it serves my purpose. Also here I cater with int, string and DateTime only, please feel free to extend to serve your purpose. You will notice I used StringBuilder above to accumulate the generated codes, but I normally use my SmartCodeGenerator and write simple templates for this kind of tricks, SmartCodeGenerator provides a lot more flexibility and comes with robust templating feature for purposes like this.

Usage

            MockHelper helper = new MockHelper();
            //Your desired class instance
            Client client = new Client();
            string code = helper.Generate(client);

Its quite simple to use the above helper, just create an instance of the MockHelper, then pass an instance of your desired class, it will return you the mock object code as we have seen above. Infact, the above piece of code can speed you up for any cases where you need to create instances of a class and need to write code to fill all its properties, moreover the generated code can also reduce chances of errors and typos that normally happens when we do it manually.

Thank you for being with me so far, hope this saves you some time, Happy coding :)

C# Reflection Tips: Data transformation using Reflection

Shahed Khan — Wed, 23 Jul 2008 19:52:24 GMT

.NET Reflection can be quite handy to transform one object to another, and specially when the target data structure varies a lot. Lets say, a "source party" has a stable Source data structure. But different clients have different requirement and expects to served with data in different format. These clients may pass their object instances in their own format and expect to be served with data in their structure. Let me make up an Example here:

Source Data Structure which is consistent and never changes.

Client 1 wants data to be transformed/served in the following structure

Client 2 wants data to be transformed/served in the following structure

and there may be other N-number of clients with N-number of structures, on which "Source Party" has no control.

The use of .NET Attribute and .NET Reflection can produce a very powerful solution to address this kind of scenario. So instead of writing different transforms for different clients, "source party" can simply ask clients to mark their class properties with custom attributes that the "source party" can understand. When clients mark their classes with custom attributes the "source party" can easily take advantage of .NET Reflection to analyze those objects runtime and can act accordingly.

A .NET Attribute class can be designed to keep track of of the Mapping between the source and target data structure.

The client can mark their class/properties with this custom attribute for the (target -> source) mapping.

As the mapping has been performed, we can take advantage of .NET Reflection to transform/serve data in different structure ( infact any structure - considering mapping is done properly ). Lets look at the following magical piece of code.

public class TransformHelper
{
    public Source SourceObject { get; set; }
    public object GetTransformedObjectObject(object obj)
    {
        foreach (PropertyInfo property in obj.GetType().GetProperties())
        {
            FillObject(property, obj);
        }
        return obj;
    }

    private void FillObject(PropertyInfo property, object obj)
    {
        //Identify Custom attribute
        SourceMapAttribute attribute = (SourceMapAttribute)Attribute.GetCustomAttribute(property, typeof(SourceMapAttribute));
        if (attribute != null)
        {
            //Check propertyName
            /*Put your desired code and logic here.*/
            if (attribute.PropertyName != string.Empty)
            {
                /*Put your desired code and logic here.
                I have simply demonstrated with one attribute property,
                you can have as many as you like, and can perform any complex operation you prefer.*/

                //Get Source Object Value
                object sourceValue = GetSourceValue(attribute.PropertyName);
                if (property.CanWrite)
                {
                    //Assign source value to the mapped property
                    property.SetValue(obj, sourceValue, null);
                }
            }

Type propertyType = property.PropertyType;
object propertyInstance = property.GetValue(obj, null);

            if (propertyInstance == null)
            {
                //Instantiate when Property is not instantiated
                propertyInstance = Activator.CreateInstance(property.PropertyType);
                if (property.CanWrite)
                    property.SetValue(obj, propertyInstance, null);
            }

            foreach (PropertyInfo info in propertyType.GetProperties())
            {
                //recursive call
                FillObject(info, propertyInstance);
            }
        }
    }

    private object GetSourceValue(string propertyName)
    {
        if (SourceObject == null)
        {
            SourceDataProvider provider = new SourceDataProvider();
            this.SourceObject = provider.GetSource();
        }

        switch (propertyName)
        {
            case "FirstName":
                return SourceObject.FirstName;
            case "LastName":
                return SourceObject.LastName;
            case "ContactAddress":
                return this.SourceObject.ContactAddress;
            case "ContactPhone":
                return this.SourceObject.ContactPhone;
            case "ContactMobile":
                return this.SourceObject.ContactMobile;
            case "ShippingAddress":
                return this.SourceObject.ShippingAddress;
            case "ShippingPhone":
                return this.SourceObject.ShippingPhone;
            case "ShippingMobile":
                return this.SourceObject.ShippingMobile;
            default:
                return string.Empty;
        }
    }
}

Its worth talking a little bit about the above code snippet, all it does is takes an instance of the target class, uses reflection to loop through all its properties, while doing that identifies the custom attributes, checks for the mapping property and assigns values from the Source. This also creates property instances as required and recursively keeps working until all the properties ( including all descendents ) are checked and served.

Lets look at this Transformer in action.

Serve Client 1:

Here is what we see after transformation.

Serve Client 2:

and here is the result.

In this way we can serve any clients objects in any structure ( considering, mapping is done properly ). You will sure agree with me Transforming one object to another by taking advantage of .NET Attribute and .NET Reflection is quite cool. Thank you for being with me so far, Happy coding :)

ASP.NET tips: Golden rules for Dynamic Controls.

Shahed Khan — Wed, 25 Jun 2008 16:36:46 GMT

1. Make sure your dynamic controls are Loaded on every postback.

Lets play with a very simple example,

ASPX

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

C# Code Behind

public partial class _Default : System.Web.UI.Page
{
    protected void Page_Load(object sender, EventArgs e)
    {
        TextBox t = new TextBox();
        t.ID = "textBox";
        this.PlaceHolder1.Controls.Add(t);
    }

}

The above code works fine, but a common mistake is to try to conditionally load dynamic controls, if we tweak the code a little bit you will notice we loose our TextBox after any postback. The following code will not load the TextBox after our first postback.

public partial class _Default : System.Web.UI.Page
{
    protected void Page_Load(object sender, EventArgs e)
    {
       if (!IsPostBack)
        {
            TextBox t = new TextBox();
            t.ID = "textBox";
            this.PlaceHolder1.Controls.Add(t);
        }
    }

}

Its recommended to load the dynamic controls during the Page_Init instead, because we may want to hook up our events with proper handler at an early stage.

public partial class _Default : System.Web.UI.Page
{
    protected void Page_Init(object sender, EventArgs e)
    {
        TextBox t = new TextBox();
        t.ID = "textBox";
        t.TextChanged+=new EventHandler(t_TextChanged);
        this.PlaceHolder1.Controls.Add(t);
    }

}

2. Do not assigning properties of a dynamic control (viewstate enabled), during Page_Init, it will not be reflected.

Here is scenario of another common mistake, "123" assigned to the Text property during Page_Init,

public partial class _Default : System.Web.UI.Page
{
    protected void Page_Init(object sender, EventArgs e)
    {
        TextBox t = new TextBox();
        t.ID = "textBox";
       t.Text = "123";
        this.PlaceHolder1.Controls.Add(t);
    }

}

the above code will not work because, Initialization happens before LoadViewState during the control lifecycle. The value assigned to the properties during Initialization will simply get overwritten by the ViewState values.

3. If you are expecting your ViewState to retain after the postback, always assign same ID to the dynamic control

The following piece of code will not work, as I am assigning a new ID to the dynamic control after each postback. The LoadViewState retrieves previously saved viewstate data using the control ID, as the control ID has changed, it doesn't know anymore what to load, as a result it cannot load previously saved viewstate data any more.

public partial class _Default : System.Web.UI.Page
{
    protected void Page_Init(object sender, EventArgs e)
    {
        TextBox t = new TextBox();
        t.ID = Guid.NewGuid().ToString();
        this.form1.Controls.Add(t);
    }
}

Thank you for being with me so far.

ASP.NET tips, Making Custom Validators work in Partial Rendering mode.

Shahed Khan — Mon, 16 Jun 2008 19:43:27 GMT

Introduction

There are many situations where we need to identify if partial rendering is supported in a page, especially when a control uses javascript, to get the control work in partial rendering mode, the script needs to be registered using a ScriptManager Type instead. A classic example will be Validators.

The ASP.NET Page class exposes the Validators property, which is a list of all the IValidator types on the page. A page keeps track of its validators, and registers a javascript array of validators automatically to the page. Example, When we add 3 RequiredFieldValidator in a page the following javascript Array will be automatically generated and added in our page automatically during the page load.

Page_Validators = new Array(document.getElementById("RequiredFieldValidator1"),
document.getElementById("RequiredFieldValidator2"),
document.getElementById("RequiredFieldValidator3"));

The ASP.NET Page also registers couple of other script which eventually hooks up different events ( onclick, onkeypress, onchange, onblur ) to the the target control (ControlToValidate), to some predefined javascript functions that resides in WebUIValidation.js file. So when we add a validator in our Page we also notice the following script is automatically added. [WebUIValidation.js ships with ASP.NET and resides in the following folder "/aspnet_client/system_web/<version>/WebUIValidation.js".]

function ValidatorOnSubmit() {
if (Page_ValidationActive) {
return ValidatorCommonOnSubmit();
}
else {
return true;
}
}
// -->
</script>

ValidatorOnLoad plays the big role of hooking up the the events mentioned above, and here is a code snippet from this function,

for (i = 0; i < Page_Validators.length; i++) {
val = Page_Validators[i];
if (typeof(val.evaluationfunction) == "string") {
eval("val.evaluationfunction = " + val.evaluationfunction + ";");
}
...

if (typeof(val.controltovalidate) == "string") {
ValidatorHookupControlID(val.controltovalidate, val);
}
...
}

keen eyes may have already noticed the val.evaluationfunction property, yes every validators needs to have this property for it to work properly under the ASP.NET validation framework. Custom validators takes advantage of this property to point to custom js functions. Custom validator developers normally use RegisterExpandoAttribute method to register this attribute.

protected override void AddAttributesToRender(System.Web.UI.HtmlTextWriter writer)
{
   base.AddAttributesToRender(writer);
   if (this.RenderUplevel)
   {
      string clientID = this.ClientID;
      Page.ClientScript.RegisterExpandoAttribute(clientID, "evaluationfunction", "EntryValidatorEvaluateIsValid");
   }
}

Problem
When I used Update Panel with partial rendering enabled the Page.ClientScript.RegisterExpandoAttribute did not work for me. My validators always stopped working after the first postback, which was performed via partial rendering and triggering. I found the "evaluationfunction" in the javascript to be undefined.

Solution
I started looking under the hood, and soon discovered, that the ASP.NET Validators that ships out of the box, ( eg. RangeValidator, RequiredFieldValidator ) uses a different internal method "AddExpandoAttribute" to register the property. Here is a code snippet from the RangeValidator.

protected override void AddAttributesToRender(HtmlTextWriter writer)
{
    base.AddAttributesToRender(writer);
    if (base.RenderUplevel)
    {
        string clientID = this.ClientID;
        HtmlTextWriter writer2 = base.EnableLegacyRendering ? writer : null;
        base.AddExpandoAttribute(writer2, clientID, "evaluationfunction", "RangeValidatorEvaluateIsValid", false);
        ...
    }
}

and code snippet from BaseValidator, the internal method AddExpandoAttribute.

internal void AddExpandoAttribute(HtmlTextWriter writer, string controlId, string attributeName, string attributeValue, bool encode)
{
AddExpandoAttribute(this, writer, controlId, attributeName, attributeValue, encode);
}

After digging further I realized, AddExpandoAttribute checks the ASP.Page whether partial rendering is supported, then it registers the attribute using ScriptManager instead. I did the same with my validation control and it works for me. Here is the piece of code that solved my problem.

protected override void AddAttributesToRender(System.Web.UI.HtmlTextWriter writer)
       {
           base.AddAttributesToRender(writer);
           if (this.RenderUplevel)
           {
               string clientID = this.ClientID;
               if (!this.IsPartialRenderingSupported)
               {
                   Page.ClientScript.RegisterExpandoAttribute(clientID, "evaluationfunction", "EntryValidatorEvaluateIsValid");
               }
               else
               {
                   Type scriptManagerType = BuildManager.GetType("System.Web.UI.ScriptManager", false);
                   scriptManagerType.InvokeMember("RegisterExpandoAttribute", BindingFlags.InvokeMethod | BindingFlags.Public | BindingFlags.Static, null, null, new object[] { this, clientID, "evaluationfunction", "QuantityEntryValidatorEvaluateIsValid", false });
               }
           }
       }

Note, the I am first checking whether Partial Rendering is Supported and using the ScriptManager Type to register the property instead.

The following piece of code uses Reflection to figure out whether partial rendering is supported.

internal bool IsPartialRenderingSupported
{
    get
    {
        if (!this.PartialRenderingChecked)
        {
            Type scriptManagerType = BuildManager.GetType("System.Web.UI.ScriptManager", false);
            if (scriptManagerType != null)
            {
                object obj2 = this.Page.Items[scriptManagerType];
                if (obj2 != null)
                {
                    PropertyInfo property = scriptManagerType.GetProperty("SupportsPartialRendering");
                    if (property != null)
                    {
                        object obj3 = property.GetValue(obj2, null);
                        this.IsPartialRenderingEnabled = (bool)obj3;
                    }
                }
            }
            this.PartialRenderingChecked = true;
        }
        return this.IsPartialRenderingEnabled;
    }

}

private bool PartialRenderingChecked
{
    get
    {
        object val = ViewState["PartialRenderingChecked"];
        if (val != null)
            return (bool)val;
        return false;
    }
    set
    {
        ViewState["PartialRenderingChecked"] = value;
    }
}

private bool IsPartialRenderingEnabled
{
    get
    {
        object val = ViewState["IsPartialRenderingEnabled"];
        if (val != null)
            return (bool)val;
        return false;
    }
    set
    {
        ViewState["IsPartialRenderingEnabled"] = value;
    }
}

Conclusion

The Page.ClientScript.RegisterExpandoAttribute may not work in Partial Rendiring mode, when a postback is performed via triggering,
to get this work we need to determine whether partial rendering is supported and use the ScriptManager Type instead like described above.

Hope this helps, and saves some of your time, Thank you for being with me so far.

C# 3.0 tips, Automatic Property

Shahed Khan — Tue, 10 Jun 2008 14:21:52 GMT

Declaring a property in C# 3.0 is super easy and super short.

public class Student
{
public string Name { get; set; }
}

yes that's it, the framework will take care of the rest, the private variables will be automatically created and the getter and setter will be automatically implemented.

Here is how we can assign value to an automatic property via the constructor

public class Student
{
    public string Name { get; set; }
    public Student (string name)
    {

this.Name = name;

}
}

And finally, here is how we can declare a Readonly property

public class Student
{

public string Name { get; private set; }

public Student (string name)
{

this.Name = name;

}
}

Hope this helps, Enjoy coding.