Affordable, Php5, Web Design Programs - Tomcat Web Hosting

Appendix E Generating Documentation in Visual Studio 1337 9 ///

/// Class CircleTest test the 11 /// Point and Point classes. 12 ///

13 class CircleTest 14 { 15 ///

16 /// Entry point of application. 17 ///

18 /// 19 /// In this application all command-line arguments /// are ignored. 21 /// 22 ///
23 /// Optional arguments to Main. 24 /// 25 static void Main( string[] args ) 26 { 27 Circle circle = new Circle( 37, 43, 2.5 ); 28 29 // append Circle properties to output string output = “X coordinate is ” + circle.X + “n” + 31 “Y coordinate is ” + circle.Y + “n” + 32 “Radius is ” + circle.Radius; 33 34 // set new coordinates and radius 35 circle.X = 2; 36 circle.Y = 2; 37 circle.Radius = 4.25; 38 39 output += “nn” + “The new location and radius of circle are ” + 41 “n” + circle + “n”; 42 43 // display Circle’s Diameter 44 output += “Diameter is ” + 45 String.Format( “{0:F}”, circle.Diameter() ) + “n”; 46 47 // display Circle’s Circumference 48 output += “Circumference is ” + 49 String.Format( “{0:F}”, circle.Circumference() ) + “n”; 51 // display Circle’s Area 52 output += “Area is ” + 53 String.Format( “{0:F}”, circle.Area() ); 54 55 MessageBox.Show( output, “Demonstrating Class Circle” ); 56 57 } // end method Main 58 59 } // end class CircleTest } Fig. E.3 Fig. E.3Fig. E.FiFi3g. E.3g. E.3CircleTestclass marked up with XML comments. (Part 2 of 3.)
You want to have a cheap webhost for your apache application, then check apache web hosting services.

1336 Generating Documentation in Visual Studio Appendix E 108 public double Circumference() 109 { 110 return Math.PI * Diameter(); 111 } 112 113 ///

114 /// Computes the area of the circle. 115 ///

116 /// 117 /// Uses constant Math.PI 118 /// 119 /// 120 /// 121 /// Returns the area of the circle. 122 /// 123 public double Area() 124 { 125 return Math.PI * Math.Pow( Radius, 2 ); 126 } 127 128 ///

129 /// Converts the Circle to 130 /// string format. 131 ///

132 /// 133 /// Overrides ToString method of base class. 134 /// 135 /// 136 /// 137 /// Returns a string that includes the center of the 138 /// circle and its radius. 139 /// 140 public override string ToString() 141 { 142 return “Center = ” + base.ToString() + 143 “; Radius = ” + Radius; 144 } 145 146 } // end class Circle 147 } Fig. E.2 Fig. E.2Fig. E.FiFi2g. E.2g. E.2Circleclass marked up with XML comments. (Part 4 of 4.) 1 // Fig. E.3: CircleTest.cs 2 // Manipulating a Circle object. 3 4 using System; 5 using System.Windows.Forms; 6 7 namespace CircleTest 8 { Fig. E.3 Fig. E.3Fig. E.FiFi3g. E.3g. E.3CircleTestclass marked up with XML comments. (Part 1 of 3.)
Visit our web design programs services for an affordable and reliable webhost to suit all your needs.

Appendix E Generating Documentation in Visual Studio 1335 56 Radius = radiusValue; 57 } 58 59 ///

60 /// Provides get and set access to member 61 /// radius. 62 ///

63 /// 64 /// The set method ensures 65 /// that radius is 66 /// not set to a 67 /// negative number. 68 /// 69 /// 70 /// Radius accesses the value of the 71 /// radius data member. 72 /// 73 public double Radius 74 { 75 get 76 { 77 return radius; 78 } 79 80 set 81 { 82 if ( value >=0 ) 83 radius = value; 84 } 85 } 86 87 ///

88 /// Computes the diameter of the circle. 89 ///

90 /// 91 /// Returns the diameter of the circle. 92 /// 93 public double Diameter() 94 { 95 return Radius * 2; 96 } 97 98 ///

99 /// Computes the circumference of the circle. 100 ///

101 /// 102 /// Uses constant Math.PI 103 /// 104 /// 105 /// 106 /// Returns the circumference of the circle. 107 /// Fig. E.2 Fig. E.2Fig. E.FiFi2g. E.2g. E.2Circleclass marked up with XML comments. (Part 3 of 4.)
Searching for affordable and reliable webhost to host and run your web applications? Go to our java web server services and you will be pleased.

1334 Generating Documentation in Visual Studio Appendix E 3 4 using System; 6 namespace CircleTest 7 { 8 ///

9 /// Class Circle inherits from class /// Point. It has an additional member to 11 /// represent the radius, a property that provides access 12 /// to it and method Area to compute the area 13 /// of the circle. 14 ///

public class Circle : Point 16 { 17 ///

18 /// This private member of Circle 19 /// represents the radius. ///

21 private double radius; 22 23 ///

24 /// Default constructor for class Circle. ///

26 /// 27 /// Sets the radius to 0. 28 /// 29 public Circle() { 31 // implicit call to base class constructor occurs here 32 } 33 34 ///

/// Constructor for Circle that accepts two integers 36 /// that represent the x- and y-coordinates of the circle 37 /// and a double that represents the radius. 38 ///

39 /// /// Uses property Radius to set the radius 41 /// of the circle, not private member 42 /// radius. 43 /// 44 ///
/// The x-coordinate of the circle 46 /// 47 ///
48 /// The y-coordinate of the circle. 49 /// ///
51 /// The radius of the circle. 52 /// 53 public Circle( int xValue, int yValue, double radiusValue ) 54 : base( xValue, yValue ) { Fig. E.2 Fig. E.2Fig. E.FiFi2g. E.2g. E.2Circleclass marked up with XML comments. (Part 2 of 4.)
Go visit our java server pages services for a reliable, lowcost webhost to satisfy all your needs.

Appendix E Generating Documentation in Visual Studio 1333 73 get 74 { 75 return x; 76 } 77 78 set 79 { 80 x = value; 81 } 82 } 83 84 ///

85 /// Provides get and set access to member 86 /// y. 87 ///

88 /// 89 /// Y accesses the value of the 90 /// y data member. 91 /// 92 public int Y 93 { 94 get 95 { 96 return y; 97 } 98 99 set 100 { 101 y = value; 102 } 103 } 104 105 ///

106 /// Converts the Point to 107 /// string format. 108 ///

109 /// 110 /// Returns a string in format: 111 /// [x coordinate, y coordinate]. 112 /// 113 public override string ToString() 114 { 115 return “[”+ X + “, ” + Y + “]”; 116 } 117 118 } // end class Point 119 } Fig. E.1 Fig. E.1Fig. E.FiFi1g. E.1g. E.1Pointmarked up with XML comments. (Part 3 of 3.) 1 // Fig. E.2: Circle.cs 2 // Class Circle inherits from Point. Fig. E.2 Fig. E.2Fig. E.FiFi2g. E.2g. E.2Circleclass marked up with XML comments. (Part 1 of 4.)
Check Tomcat Web Hosting services for best quality webspace to host your web application.

1332 Generating Documentation in Visual Studio Appendix E 20 21 ///

22 /// This private member of Point 23 /// represents the x coordinate. 24 ///

25 /// The y coordinate as an integer. 26 private int y; 27 28 ///

29 /// Default constructor for class Point. 30 ///

31 /// 32 /// Sets properties X and Y to 0. 33 /// 34 public Point() 35 { 36 // implicit call to base-class constructor occurs here 37 } 38 39 ///

40 /// Constructor for Point that accepts two 41 /// integers that represent the x-and 42 /// y coordinates of the point. 43 ///

44 /// 45 /// Uses X and Y 46 /// properties to set the coordinates of the point, 47 /// not private members x 48 /// and y. 49 /// 50 ///
51 /// The x coordinate of the circle 52 /// 53 ///
54 /// The y coordinate of the circle. 55 /// 56 public Point( int xValue, int yValue ) 57 { 58 // implicit call to base-class constructor occurs here 59 X = xValue; 60 Y = yValue; 61 } 62 63 ///

64 /// Provides get and set access to member 65 /// x. 66 ///

67 /// 68 /// X accesses the value of the 69 /// x data member. 70 /// 71 public int X 72 { Fig. E.1 FiFiFiFig.g.g.g. E.E.E.E.1111Pointmarked up with XML comments. (Part 2 of 3.)
Looking for affordable and reliable webhost to host and run your business application? Then look no more and go to servlet web hosting services.

Appendix E Generating Documentation in Visual Studio 1331 /// this is a comment /// In this comment, the first line begins element summary, the second line defines the text that element summary contains and the third line closes element summary. As we will discuss later in this text, the documentation tool will document only the text within these summary tags. All XML declaration comments (excluding the three forward slashes) must contain well-formed XML. Like general comments, the compiler does not translate documentation comments to MSIL (Microsoft Intermediate Language), so they do not become part of the program. Because the documentation tool creates XML files, documentation comments can contain certain types of markup, such as HTML tags and customized XML content. For example, the documentation comment ///

/// Sorts integer array using MySort algorithm ///

contains the HTML tags and . In the generated HTML files, MySortappears as emphasized text (normally italic). E.3 Documenting C# Source Code Figure E.1, Fig. E.2 and Fig. E.3 present a modified version of the Point, Circle and CircleTest classes from Section 9.4 that contains XML documentation comments. In the text that follows the example, we discuss each XML element used in the documentation comments. In Section E.4, we discuss how the documentation tool can generate XML documentation from this file. 1 // Fig. E.1: Point.cs 2 // Class Point maintains an X and Y coordinate. 3 4 using System; 5 6 namespace CircleTest 7 { 8 ///

9 /// Class Point defines a point as a pair 10 /// of x and y coordinates. 11 ///

12 public class Point 13 { 14 ///

15 /// This private member of Point 16 /// represents the x coordinate. 17 ///

18 /// The x coordinate as an integer. 19 private int x; Fig. E.1 Fig. E.1Fig. E.FiFi1g. E.1g. E.1Pointmarked up with XML comments. (Part 1 of 3.)
If you are looking for affordable and reliable webhost to host and run your business application visit our ftp web hosting services.

1330 Generating Documentation in Visual Studio Appendix E Outline E.1 Introduction E.2 Documentation Comments E.3 Documenting C# Source Code E.4 Creating Comment Web Pages E.5 Creating XML Documentation Files Terminology Summary E.1 Introduction A single programmer can implement most of the programs from this book. However, industrial software is more complex, and each project almost always requires the talent of several programmers. In such projects, communication among programmers is a necessity. When a programmer writes code for a class, programmers from the same group should understand how that class operates. For this reason, each programmer should document specific information on a class, such as the class s role in a system, the functionality that each method provides for the class and the purpose of each class variable. This documentation helps all programmers understand how classes can interoperate, and facilitates modification, use and extension of each class. To facilitate the creation of documentation for a project, Visual Studio .NET provides the XML documentation tool. This tool converts key pieces of information in source code such as the class s members, the hierarchy to which the class belongs and any other general remarks the programmer wishes to document to HTML1 or XML2 format. The programmer specifies the general remarks to be documented by placing them in special regions in the code, called XML documentation comments. In this appendix, we introduce Visual Studio .NET s documentation capabilities. We begin by discussing the format and structure of the XML documentation comments that the documentation-generation tool uses to create the documentation files. We then show how to generate the documentation through a LIVE-CODE example. We recommend reading through Chapters 8 10 before reading this appendix, because the examples presented in this appendix relate to the examples from these chapters. E.2 Documentation Comments Before the Visual Studio documentation-generation tool can generate documentation files, the programmer must insert XML documentation comments into the source files. These comments contain the information that the programmer wishes to document. The documentation- generation tool recognizes only single-line comments that begin with three forward slashes (///). An example of a simple documentation comment is ///

1. HTML is discussed in Appendices I and J. 2. XML is discussed in Chapter 18.
If you are in need for chaep and reliable webhost to host your website, our recommendation is http web server services.

E Generating Documentation in Visual Studio Objectives To introduce Visual Studio .NET s documentation generation tool. To introduce XML documentation comments. To understand XML documentation tags and their use. To be able to generate HTML and XML documentation files.
Visit our web design programs services for an affordable and reliable webhost to suit all your needs.

1328 Visual Studio .NET Debugger Appendix D To enable the debugging features, the program must be compiled using the debug configuration. To set breakpoints, click the gray area to the left of any line of code. Alternatively, right-click a line of code and select Insert Breakpoint. The Watch window allows the programmer to examine variable values and expressions. To examine data, type a valid Visual Basic expression, such as a variable name, into the Name field. Once the expression has been entered, its type and value appear in the Type and Value fields. Variables in the Watch window can be modified by the user for testing purposes. To modify a variable s value, click the Value field and enter a new value. The Locals window displays the name and current value for all the local variables or objects in the current scope. The Autos window displays the variables and objects used in the previous statement and the current statement (indicated by the yellow arrow). To evaluate an expression in the Immediate window, simply type the expression into the window and press Enter. The Continue button resumes execution of a suspended program. The Stop Debugging button ends the debugging session. The Break All button allows the programmer to place an executing program in break mode. The Show Next Statement button places the cursor on the same line as the yellow arrow that indicates the next statement to execute. The Step Over button executes the next executable line of code and advances the yellow arrow to the following executable line in the program. If the line of code contains a method call, the method is executed in its entirety as one step. The Hex button toggles the display format of data. If enabled, Hex displays data in a hexadecimal (base 16) form, rather than decimal (base 10) form. The Breakpoints window displays all the breakpoints currently set for a program. Disabled breakpoints allow the programmer to maintain breakpoints in key locations in the program so they can be used again when needed. The Call Stack window contains the program s method call stack, which allows the programmer to determine the exact sequence of calls that led to the current method and to examine calling methods on the stack. The Step Over button executes one statement in a method, then pauses program execution. The Step Into button executes next statement. If the statement contains a method call, control transfers to the method for line-by-line debugging. If the statement does not contain a method call, Step Into behaves like Step Over. The Step Out finishes executing the method and returns control to the line that called the method. The Immediate window is useful for testing arguments passed to a method. This helps determine if a method is functioning properly. Visual Studio .NET includes class debugging features which allow the programmer to determine the current state of any objects used in a program. To assist class debugging, Visual Studio .NET allows the programmer to expand and view all data members variables and properties of an object, including those declared private.
Please visit our professional web hosting services to find out about cheap and reliable webhost service that will surely answer all your demands.