Recipe 3.20 Using Multiple Entry Points toVersion an Application

Problem

Some companies reuse the same duplicated, but slightly modified, application, with each version built especially for a particular client or group of clients. Bug fixes, testing, adding, and modifying code in each of these code bases can get very confusing as the number of duplicated applications grows. You need a way of managing this increasing complexity.

Solution

Instead of copying the entire application to a different area, modifying the duplicated code, and creating a special build script for it, you could compile the same application (with all modifications included, of course) and use a different entry point based on the client. To do this, add a new class with a new Main entry point method, one for each client or group of clients:

public class ClientABC
{
    public static void Main( )
    {
        //Startup/Initialization code for client ABC
    }
}

public class ClientXYZ
{
    public static void Main( )
    {
        //Startup/Initialization code for client XYZ
    }
}

The build scripts can be modified to build the same application using a different entry point that matches up to one or more clients:

csc /out:AppABC.exe *.cs /main:ClientABC 
csc /out:AppXYZ.exe *.cs /main:ClientXYZ

Discussion

It is very difficult to work with several slightly different copies of the same application. If a bug is found and fixed in one application, it must be fixed in all of the copies as well. This can be a time-consuming and arduous task. To make things easier on your coding team, consider using multiple entry points into your application, one for each client or set of clients. Using this technique, you can fix code in one place as opposed to fixing the same bug over multiple applications.

The /main compiler switch controls the class in which the compiler looks for a public static Main method that it can use as an entry point. If the compiler finds a /main switch, the Main method at the location specified in this switch is used as the entry point and all other Main methods in the application are considered as regular methods and nonentry points.

You should note that only one Main entry point method is allowed per class. If two or more are found in a single class, a compiler error will result. You can have entry points in both a nested class and its parent class, as shown here:

public class ClientABC
{
    public static void Main( )
    {
        //Startup/Initialization code for client ABC
    }

    public class ClientXYZ
    {
        public static void Main( )
        {
            //Startup/Initialization code for client XYZ
        }
    }
}

The /main compiler option would have to be modified in this case to the following:

csc /out:AppABC.exe *.cs /main:ClientABC 
csc /out:AppXYZ.exe *.cs /main:ClientABC.Clientxyz

Also note that if classes ClientABC and ClientXYZ were nested in a namespace—the MyCompany namespace, for instance—the namespace would also have to be added to this compiler switch, as follows:

csc /out:AppABC.exe *.cs /main:MyCompany.ClientABC 
csc /out:AppXYZ.exe *.cs /main:MyCompany.ClientABC.Clientxyz

The /main switch can be modified through the Visual Studio .NET Property Pages dialog box. If you open this dialog box, drill down to the Common Properties General Startup Object property. The fully qualified class name containing the Main method entry point can be entered in this property.

See Also

See the "/main" compiler option and the "Main" topic in the MSDN documentation.