Author: andrewpallant

For some applications it seems to me that the web interface may be at it is limits. For those applications that need large amounts of data on display on a single screen that also include calculations and database updates a Single Click Deployment may be a better option. With more updates, calculations and data on a web interface, the more bloated the page becomes. When the page is bloated, it means the updates and page refreshes become slower. It doesn’t matter if the page is using AJAX, it is still bloated. As a test, load all the data the user needs and check the page size. Most of the page size will probably be found in the ViewState.

In my cases, I had applications that needed ViewState to exist and placing the ViewState in the database or at the server levels did not help the load or refresh times.

Single Click Deployments are a method of deploying a desktop application to multiple workstations on a network. This means when the developer deploys an update, the update gets pushed out when the application starts on the workstation. This works well on a closed network or VPN, but it can be rolled out to internet users. Generally speaking the web interface is stateless while the desktop version is live data and holds state. The advantage is the Single Click Deployment allows for heavy calculations and heavy data displays to take outside the confines of a web browser and to use the users resources instead of the IIS (Web Server) resources. This means the user does not have to wait for updates and refreshes.

Note: If rolled out to internet users, you will have to deploy using WebServices to fetch and update data.

I am not saying to stop using the Web Interface.   In fact I do use it; however, for those applications that require large amounts of data, calculations, look-ups and updates, I tend to push towards a desktop application using Single Click Deployments.   The user has been found to be much happier and less support calls.

More to come…

s.equals(x);

Will return true if the strings s and x contain the same character sequence. So:

String s = new String(“foobar”);
String x = new String(“foobar”);

Then s.equals(x) will return true, but s == x will be false, because s and x are not the same String Object.

If you then do:

String y = s;
String t = x;

You have a case where any string of the 4, .equals() any other string of the 4 (s, t, x, y) will return true, but only s == y or t == x will return true. That is because they refer to the same object.

When you have a class inherit another class, sometimes you want the base level class to create a collection of the top-level class.  In this blog I will demonstrate some basic inheritance and a little reflection trick.  Note the examples are in C#, but could easily be done in VB.NET

Why you may want to do this?  You may want to create a base class to handle all of your basic database functions from which your data layer classes will inherit to limit duplicate code.  In the base class you may create a “SELECT” function to return multiple rows of data.  The rows of data being returned are represented by the top-level class, for which you need a collection of the base level class.

You need two components or classes.  The first is to create your base class from which you will inherit later on.  In the base class you will create a method to generate a collection of the top-level class.  The example being used is passing in the size of collection to be returned, but you could have it being auto generated based on number of database rows.

public class BaseClass
{
    public String FirstName { get; set; }

    public BaseClass()
    {
    }

    public ArrayList getCollection(String className, int limit)    
    {
         ArrayList collection = new ArrayList();

        Type t = Type.GetType(className); 
        for ( int icount=0; icount < limit; icount++ )
        {
             object clss = Activator.CreateInstance(t); 
             ((BaseClass)clss).FirstName = "Bob"; 
             collection.Add(clss);                      
         }

         return collection;
    }
}

The next part is to create a class that inherits the base class.  From this new class we are going to make a public function that will return the requested collection.  Remember; you could be returning class collection of data rows or another single purpose that could be represented by a class.

public class ClassInherit : BaseClass
{
     public ClassInherit()
     {
     }

     public ArrayList BuildCollection()
     {
         return getCollection("ClassInherit", 4);
     }
}

If you have questions regarding this blog or the purpose of this blog, please feel free to contact me at www.unlatched.com or www.andrewpallant.com.