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.

Preface

Index

    Introduction to Computers, the Internet and Visual C#

    Introduction to the Visual C# 2005 Express Edition IDE

    Introduction to C# Applications

    Introduction to Classes and Objects

    Control Statements: Part 1

    Control Statements: Part 2

    Methods: A Deeper Look

    Arrays

    Classes and Objects: A Deeper Look

    Object-Oriented Programming: Inheritance

    Polymorphism, Interfaces & Operator Overloading

    Exception Handling

    Graphical User Interface Concepts: Part 1

    Graphical User Interface Concepts: Part 2

    Multithreading

    Strings, Characters and Regular Expressions

    Graphics and Multimedia

    Files and Streams

    Extensible Markup Language (XML)

    Database, SQL and ADO.NET

    ASP.NET 2.0, Web Forms and Web Controls

    Web Services

    Networking: Streams-Based Sockets and Datagrams

    Searching and Sorting

    Data Structures

    Generics

    Collections

    Appendix A. Operator Precedence Chart

    Appendix B. Number Systems

    Appendix C. Using the Visual Studio 2005 Debugger

    Appendix D. ASCII Character Set

    Appendix E. Unicode®

    Appendix F. Introduction to XHTML: Part 1

    Appendix G. Introduction to XHTML: Part 2

    Appendix H. HTML/XHTML Special Characters

    Appendix I. HTML/XHTML Colors

    Appendix J. ATM Case Study Code

    Appendix K. UML 2: Additional Diagram Types

    Appendix L. Simple Types

    Index



    Visual C# How to Program
    Visual C# 2005 How to Program (2nd Edition)
    ISBN: 0131525239
    EAN: 2147483647
    Year: 2004
    Pages: 600

    Similar book on Amazon

    Flylib.com © 2008-2017.
    If you may any questions please contact us: flylib@qtcs.net