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.
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
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.