Using Command-Line Arguments

On many systems, it is possible to pass arguments from the command line (these are known as command-line arguments) to an application by including a parameter of type string[] (i.e., an array of strings) in the parameter list of Main, exactly as we have done in every application in the book. By convention, this parameter is named args (Fig. 8.23, line 7). When an application is executed from the Command Prompt, the execution environment passes the command-line arguments that appear after the application name to the application's Main method as strings in the one-dimensional array args. The number of arguments passed from the command line is obtained by accessing the array's Length property. For example, the command "MyApplication a b" passes two command-line arguments to application MyApplication. Note that command-line arguments are separated by white space, not commas. When the preceding command executes, the Main method entry point receives the two-element array args (i.e., args.Length is 2) in which args[ 0 ] contains the string "a" and args[ 1 ] contains the string "b". Common uses of command-line arguments include passing options and file names to applications.

Figure 8.23. Using command-line arguments to initialize an array.

 1 // Fig. 8.23: InitArray.cs
 2 // Using command-line arguments to initialize an array.
 3 using System;
 4
 5 public class InitArray
 6 {
 7 public static void Main( string[] args )
 8 {
 9 // check number of command-line arguments
10 if ( args.Length != 3 )
11 Console.WriteLine(
12 "Error: Please re-enter the entire command, including
" +
13 "an array size, initial value and increment." );
14 else
15 {
16 // get array size from first command-line argument
17 int arrayLength = Convert.ToInt32( args[ 0 ] );
18 int[] array = new int[ arrayLength ]; // create array
19
20 // get initial value and increment from command-line argument
21 int initialValue = Convert.ToInt32( args[ 1 ] );
22 int increment = Convert.ToInt32( args[ 2 ] ); 
23
24 // calculate value for each array element 
25 for ( int counter = 0; counter < array.Length; counter++ )
26  array[ counter ] = initialValue + increment * counter; 
27
28 Console.WriteLine( "{0}{1,8}", "Index", "Value" );
29

30 // display array index and value 31 for ( int counter = 0; counter < array.Length; counter++ ) 32 Console.WriteLine( "{0,5}{1,8}", counter, array[ counter ] ); 33 } // end else 34 } // end Main 35 } // end class InitArray

 C:Examplesch08fig08_21>InitArray.exe
 Error: Please re-enter the entire command, including
 an array size, initial value and increment.

 

 C:Examplesch08fig08_21>InitArray.exe 5 0 4
 Index Value
 0 0
 1 4
 2 8
 3 12
 4 16

 

 C:Examplesch08fig08_21>InitArray.exe 10 1 2
 Index Value
 0 1
 1 3
 2 5
 3 7
 4 9
 5 11
 6 13
 7 15
 8 17
 9 19

Figure 8.23 uses three command-line arguments to initialize an array. When the application executes, if args.Length is not 3, the application prints an error message and terminates (lines 1013). Otherwise, lines 1632 initialize and display the array based on the values of the command-line arguments.

The command-line arguments become available to Main as strings in args. Line 17 gets args[ 0 ]a string that specifies the array sizeand converts it to an int value, which the application uses to create the array in line 18. The static method ToInt32 of class Convert converts its string argument to an int.

Lines 2122 convert the args[ 1 ] and args[ 2 ] command-line arguments to int values and store them in initialValue and increment, respectively. Lines 2526 calculate the value for each array element.

The output of the first sample execution indicates that the application received an insufficient number of command-line arguments. The second sample execution uses command-line arguments 5, 0 and 4 to specify the size of the array (5), the value of the first element (0) and the increment of each value in the array (4), respectively. The corresponding output indicates that these values create an array containing the integers 0, 4, 8, 12 and 16. The output from the third sample execution illustrates that the command-line arguments 10, 1 and 2 produce an array whose 10 elements are the nonnegative odd integers from 1 to 19.