List of Figures

Chapter 3: .NET Retraining Prerequisites, Part 1

Figure 3-1: Typing regedit into the Run window

Figure 3-2: The Registry Editor window ready for viewing and careful editing

Figure 3-3: The Event Viewer window showing the three types of log choices

Figure 3-4: The Scheduled Tasks window showing several example tasks scheduled

Figure 3-5: Windows Task Manager showing the Performance tab selected

Figure 3-6: The Microsoft Management Console window showing default snap-ins

Figure 3-7: The ODBC Data Source Administrator window

Figure 3-8: The Notepad editor showing some sample text

Figure 3-9: You can administer IIS through MMC.

Figure 3-10: You can administer COM+ applications using the MMC snap-in.

Chapter 4: .NET Retraining Prerequisites, Part 2

Figure 4-1: A sample Visio UML drawing

Figure 4-2: The Person class module created from a UML drawing (in Visual Basic .NET)

Figure 4-3: Sample HTML rendered in the Internet Explorer browser window

Figure 4-4: Sample HTML as text data in the Notepad editor

Figure 4-5: Sample XML viewed in the Notepad editor

Figure 4-6: Sample XML file (parsed) viewed in the IE browser

Figure 4-7: An XML document viewed in Notepad

Figure 4-8: XSLT used for transformation viewed in Notepad

Figure 4-9: HTML in IE after being rendered

Chapter 5: Inside the .NET Integrated Development Environment

Figure 5-1: The basic choices on the ISPF Primary Option Menu

Figure 5-2: Launching VS .NET from the Programs menu

Figure 5-3: The My Profile view of the Start Page

Figure 5-4: The Get Started view of the Start Page

Figure 5-5: The New Project dialog box

Figure 5-6: The Empty Project template

Figure 5-7: You can access the What's New screen view from the Start Page.

Figure 5-8: The Online Community screen view

Figure 5-9: The Search Online screen view

Figure 5-10: Mainframe ISPF PF key definitions

Figure 5-11: The Options dialog box contains advanced configuration options.

Figure 5-12: Displaying the Visual Studio .NET Command Prompt menu option

Figure 5-13: The upper portion of the New Project dialog box

Figure 5-14: Select New Project from the Get Started screen.

Figure 5-15: The New Project dialog box after making selections and changing the default project name

Figure 5-16: Find the project file in the Solution Explorer window.

Figure 5-17: The completed code example looks like this.

Figure 5-18: Notice that the previous COBOL .NET example is shown in the recent projects found list.

Figure 5-19: The New Project dialog box with VB .NET selections

Figure 5-20: The completed VB .NET console application looks like this.

Chapter 6: The Nuts and Bolts of .NET Programming

Figure 6-1: The console window display produced by the LogicSampleCobol program

Figure 6-2: The Toolbox menu option and icon

Figure 6-3: I have selected three lines of code and copied them. An item now shows in the Clipboard Ring.

Figure 6-4: The console window display produced by the LogicSampleVB program

Figure 6-5: The Solution Explorer window with the Show All Files feature activated. The LogicSampleVB project is being viewed.

Figure 6-6: The Visual Studio .NET Command Prompt window. The command line has been prepared for execution of the ILDASM utility.

Figure 6-7: The ILDASM GUI window showing the mapped .NET data types

Figure 6-8: The ILDASM GUI window showing the mapped Procedure tag

Chapter 7: The .NET Framework

Figure 7-1: The .NET Framework abstraction layer

Figure 7-2: Preparing to launch the Microsoft Visual Studio .NET documentation

Figure 7-3: The .NET Class Library Help page from the Microsoft Visual Studio .NET Documentation feature

Figure 7-4: A portion of the .NET Class Library Help page (via the Microsoft Visual Studio .NET documentation) showing the selection of the System.Text namespace

Figure 7-5: Selecting the Object Browser feature

Figure 7-6: Clicking the Customize option in the Object Browser

Figure 7-7: Clicking the Add button in the Selected Components dialog box

Figure 7-8: Selecting mscorlib.dll from the Component Selector dialog box

Figure 7-9: The Object Browser window displaying information about the StringBuilder class

Figure 7-10: A portion of the .NET Class Library Help page (via the Microsoft Visual Studio .NET documentation) showing the interfaces available in the System namespace

Figure 7-11: A portion of the System.Object superclass hierarchy

Figure 7-12: Enter WinCV.exe in the Visual Studio .NET Command Prompt window to execute the Class Viewer.

Figure 7-13: The VS .NET IDE Solution Explorer window with the Reference node expanded to show the referenced assemblies

Figure 7-14: The VS .NET IntelliSense feature

Figure 7-15: Clicking the Property Pages icon in the Properties window

Chapter 8: The .NET Common Language Runtime

Figure 8-1: The .NET Framework objects on the managed heap

Figure 8-2: The console display of the HeapGenerationExampleCobol project

Figure 8-3: The console display of the HeapGenerationExampleVB project

Figure 8-4: The two sample applications, PerfmonCobol and PerfmonVB, have been launched and paused .

Figure 8-5: Launching Perfmon by clicking the Start button and selecting Run

Figure 8-6: Accessing the Add counter button to add performance counters

Figure 8-7: Preparing to select a performance object

Figure 8-8: Selecting a specific counter from the available choices

Figure 8-9: Preparing to click Add in the Add Counters window to complete the setup

Figure 8-10: The Performance window, with the two Perfmon sample applications processing. Their console windows are behind the Performance window.

Chapter 9: Creating and Using Objects

Figure 9-1: The overloaded constructors of the StringBuilder class

Chapter 10: A New Perspective Toward Data

Figure 10-1: The ILDASM display of SystemIOExampleCobol.exe

Figure 10-2: The ILDASM display of SystemIOExampleVB.exe

Figure 10-3: The ILDASM display of mscorlib.dll for the System.Text.StringBuilder class

Chapter 11: Database Programming with .NET

Figure 11-1: Accessing the SQL Server Books Online option

Figure 11-2: Accessing the SQL Server Service Manager

Figure 11-3: Starting the SQL Server Service Manager from the Computer Management console

Figure 11-4: The main menu of IBM's DB2I tool

Figure 11-5: Enterprise Manager offers several administrative and non-database -specific features.

Figure 11-6: SQL Server's Enterprise Manager showing the default and sample databases

Figure 11-7: The User tables of the Northwind sample database

Figure 11-8: Performing a SELECT query on the Categories table

Figure 11-9: The selected rows of the Categories table

Figure 11-10: Launching Query Analyzer from within the Enterprise Manager window

Figure 11-11: Preparing to query the Categories table using the Query Analyzer tool

Figure 11-12: Preparing to click the Execute Mode icon to change the option from "Results in Grid" to either "Results in Text" or "Results to File"

Figure 11-13: The Estimated Execution Plan for a given query. This feature will assist you in optimizing your query.

Figure 11-14: Searching VS .NET for ADO.NET information (filtered by "Fujitsu NetCOBOL for .NET")

Figure 11-15: Searching VS .NET for "(SQL) or (DATABASE)" related information (filtered by "Fujitsu NetCOBOL for .NET")

Figure 11-16: A general view of the ADO.NET technology

Chapter 12: XML in a Managed Environment

Figure 12-1: A subset of the Northwind.Customers table beginning with the ALFKI CustomerID and ending with the CACTU CustomerID

Figure 12-2: The myCustomers.xml file (in the local application bin folder) created earlier in the sample code project ReadWriteXMLDatasetExampleVB

Figure 12-3: The Create Schema feature from within the VS .NET IDE

Figure 12-4: The XML Schema file located in the local application bin folder

Figure 12-5: A high-level view of the System.Xml.XmlReader and System.Xml.XmlWriter family of classes

Figure 12-6: The System.Xml.XmlNode class and the classes derived from it

Figure 12-7: A general input and output view of the XmlDocument class

Chapter 13: Windows Forms, Web Forms, and No Forms

Figure 13-1: Preparing to create a new Windows application using the appropriate template

Figure 13-2: Selecting the Button control in the Toolbox

Figure 13-3: MyFirstWinFormVB executing after Button1 has been clicked

Figure 13-4: MyFirstWinFormCobol in Design view

Figure 13-5: Partial list (subset) of methods from the Form class

Figure 13-6: The events of the Form class

Figure 13-7: Partial list of methods from the Control lass

Figure 13-8: Partial list of events from the Control class

Figure 13-9: The Computer Management console with the Services tree view node expanded

Figure 13-10: Using the VB .NET Windows Services project template to create a new Windows Service

Figure 13-11: The general execution cycle of an ASP.NET HTTP request

Figure 13-12: Preparing to create a new COBOL .NET ASP.NET Web application in the New Project window

Figure 13-13: A new folder is created under the C: \Inetpub\ wwwroot folder location.

Figure 13-14: The WebApplicationSampleCobol project after Button and TextBox Web Forms server controls are added to the Web Form

Figure 13-15: The WebApplicationSampleVB project after Button and TextBox Web Forms server controls have been added to the Web Form

Figure 13-16: The System.Web namespace as shown in the VS .NET IDE Object Browser

Figure 13-17: The members of the System.Web.HttpContext class as shown in the VS .NET IDE Object Browser

Figure 13-18: The Application object's events and their firing order. Not shown are the PreSendRequestHeaders, PreSendRequestContent, and Error events, which can fire in a nondeterministic order.

Figure 13-19: The VS .NET IDE Toolbox with the HTML tab selected

Figure 13-20: The VS .NET IDE Toolbox with the Web Forms tab selected

Figure 13-21: The general architecture of a Web service application

Figure 13-22: The service description XML document (.wsdl) for the sample "Hello, World" applications

Chapter 14: Adding Value to Your Interface

Figure 14-1: The VS.NET IDE Properties window for the System.Windows.Forms.Form control

Figure 14-2: The Properties window for the System.Windows.Form.DataGrid control with the ToolTip property updated

Figure 14-3: A Windows application with StatusBar, ProgressBar, ToolTip, DataGrid, and Button controls added. Several properties have been updated during design time.

Figure 14-4: You can view the ToolTip display when you place your mouse pointer over the Button control.

Figure 14-5: You can view the ToolTip display when you place your mouse pointer over the DataGrid control.

Figure 14-6: The validation server controls as seen in the VS .NET IDE Toolbox

Figure 14-7: The sample application MyWebUseValidationCobol after all labels, TextBox controls, and validator controls have been added

Figure 14-8: Updating the ControlToValidate property. Optionally, you can edit the HTML directly to modify each control's properties as needed.

Figure 14-9: Executing the sample application ASP.NET application (MyWebUseValidationCobol) to demonstrate the use of validation controls

Chapter 15: Managing Cache and State for ASP.NET

Figure 15-1: Page-level events raised in order to satisfy an HTTP page request

Figure 15-2: Application/session-level events that are raised in order to satisfy an HTTP page request

Figure 15-3: A state management decision tree for ASP.NET

Figure 15-4: The Hidden HTML element in the VS .NET IDE Toolbox

Figure 15-5: Using the VS .NET Solution Explorer window to access the Web.config file

Figure 15-6: Using Windows Explorer to locate and edit the Web.config file

Figure 15-7: The user interface for the sample application StateManagementVB

Chapter 16: Reporting and Information Delivery

Figure 16-1: Selecting the Crystal Report template from the Add New Item dialog box

Figure 16-2: Selecting an "expert" from the Crystal Report Gallery dialog box

Figure 16-3: Selecting the Microsoft OLE DB Provider for SQL Server option

Figure 16-4: Entering the appropriate connection information to connect to the Pubs sample SQL Server database

Figure 16-5: Inserting the sales table from the Pubs sample database

Figure 16-6: Adding all available fields and modifying the column headings

Figure 16-7: Adding the stor_id field to the Group By box

Figure 16-8: The VS .NET IDE Solution Explorer window showing the Report file and Crystal Decisions references

Figure 16-9: The VS .NET IDE Field Explorer window

Figure 16-10: The ReportDocument file (.rpt)

Figure 16-11: The CrystalReportViewer server control in the VS .NET Toolbox

Figure 16-12: The CrystalReportViewer server control has been placed onto the Webform1.aspx file.

Figure 16-13: The report as shown in the browser window when executing the CrystalReportsExampleVB sample application

Figure 16-14: The ASP.NET Web sample project CrystalReportsExampleVB with a few enhancements added to provide navigation between each Web Form. WebForm2.aspx will be used to add "export" logic.

Figure 16-15: Using Windows Explorer outside of the VS .NET IDE to verify the creation of the exported report formats

Figure 16-16: WebForm3.aspx of the CrystalReportsExampleVB sample project with a few HREF controls added

Figure 16-17: The Computer Management console showing the SMTP service installed

Figure 16-18: The mailroot folder structure for SMTP e-mail support

Figure 16-19: An Internet e-mail message in the SMTP queue

Figure 16-20: Publishing the Crystal ReportDocument report file as a Web service

Figure 16-21: Viewing the VS .NET Solution Explorer window showing the .asmx file for the new XML Web service

Figure 16-22: The CrystalReport1Service.asmx file as seen in the automatic XML Web service testing harness

Chapter 17: Deploying Your .NET Application

Figure 17-1: C: \Program Files\Fujitsu NetCOBOL for .NET\Redist\Runtime

Figure 17-2: The VS .NET Standard toolbar exposing the Solutions Configurations drop-down box

Figure 17-3: The Configuration Manager dialog box

Figure 17-4: The project property pages Build options showing the check box used to selectively generate debugging information

Figure 17-5: The basic options to generate machine code

Figure 17-6: The VS .NET IDE Output window. Notice that the shared assembly System.dll was loaded and executed from the GAC.

Figure 17-7: Override file feature in the Deployment section of the VS .NET IDE project property pages

Figure 17-8: Preparing to add a deployment project to your existing solution

Figure 17-9: Choosing the Setup Project template

Figure 17-10: The VS .NET IDE showing the File System Editor and the updated Solution Explorer display

Figure 17-11: Adding application project output to the setup project

Figure 17-12: The Add Project Output Group dialog box

Figure 17-13: The VS .NET IDE Output window. Notice the messages showing that the Setup.exe and MyFirstWinFormCobolSetup.msi files were created.

Figure 17-14: Testing the setup project

Figure 17-15: The setup project folder and contents to be distributed

Figure 17-16: Creating a shortcut to your user's desktop or Programs menu

Figure 17-17: The Add Project Output Group window for a VB .NET Windows application

Figure 17-18: The Dependencies window for a VB .NET Windows application

Figure 17-19: The Dependencies window for a COBOL .NET Windows application

Figure 17-20: The VS .NET Add New Project window with the Setup Wizard template choice highlighted

Figure 17-21: The message I received when attempting to use the Setup Wizard template in a COBOL .NET project (Windows and/or ASP.NET)

Figure 17-22: Choosing Web Setup Project from the Add New Project window. The new project will be named WebApplicationSampleCobolSetup.

Figure 17-23: The bin subfolder underneath the Web Application Folder node in the File System Editor

Figure 17-24: Adding the content files

Figure 17-25: The Add Files window with all content files selected

Figure 17-26: The content files have been added to the Web setup project.

Figure 17-27: Using the VS .NET IDE File System Editor to change the VirtualDirectory property and the DefaultDocument property in the Properties window

Figure 17-28: Adding the content files in the Add Files window for a VB .NET ASP.NET application. By the way, if this was an ASP.NET XML Web service, I would have also added the . vsdisco file.

Figure 17-29: With the setup project selected, from your VS .NET Standard toolbar you can access the Editor menu by selecting View Editor.

Figure 17-30: The row of icons on the Solution Explorer window used for navigating to the Windows Installer editors

Figure 17-31: At a command prompt, you can enter XCOPY /? to see a listing of all of the options/switches available for use with the XCOPY DOS command.

Figure 17-32: Accessing the VS .NET Copy Project feature

Figure 17-33: The Copy Project window with default settings

Figure 17-34: Launching the Virtual Directory Creation Wizard

Figure 17-35: Enter the desired name for your virtual directory at the Virtual Directory Alias prompt.

Figure 17-36: Enter the physical location where your files will be stored at the Web Site Content Directory prompt.

Figure 17-37: The Access Permissions prompt

Figure 17-38: The new MyTestVirtualDirectory virtual directory

Chapter 18: Configuration for .NET Applications

Figure 18-1: The VS .NET Solution Explorer window showing the AssemblyInfo.vb file

Figure 18-2: The contents of the AssemblyInfo.vb (assembly manifest) file

Figure 18-3: The COBOL .NET project Property Pages window showing the assembly-level attributes

Figure 18-4: The COBOL .NET raw project file showing the updated attributes

Figure 18-5: The graphical tree view display provided by the ILDASM tool using the ReflectionDemoVB assembly

Figure 18-6: Example topic found in Microsoft's Visual Studio .NET documentation tool

Figure 18-7: The VS .NET Add New Item window to add an application configuration file to a VB .NET Windows application

Figure 18-8: Preparing to edit the Machine.config file after making the suggested backup

Figure 18-9: The ILDASM tool provides the ability to view the .hash algorithm value while viewing the assembly manifest

Figure 18-10: The VS .NET Locals window showing runtime information

Figure 18-11: The other Zone evidence values from which the MyComputer value was assigned. The display is taken from the VS .NET Locals window during runtime.

Figure 18-12: The Trace.axd file showing the evidence information that was written using the Trace.Write class/method

Figure 18-13: The User PolicyLevelType is loaded from a Security.config file. The exact location (path) varies depending on the user and version of the .NET Framework/CLR. In this case, the path is noted as C: \Documents and Settings\Administrator\Application Data\Microsoft\CLR Security Config\v1.0.3705.

Figure 18-14: The Machine PolicyLevelType is loaded from a Security.config file. The Enterprise PolicyLevelType is loaded from the Enterprisesec.config file. The location is shown in the figure. The exact path varies depending of the version of the .NET Framework/CLR. In this case, the path is noted as C: \WINNT\Microsoft.NET\Framework\v1.0.3705\CONFIG.

Figure 18-15: The Trace.axd file showing the available NamedPermissionSets per policy level

Figure 18-16: Using the .NET Framework Configuration tool to view the contents of the Execution permission set (within the Enterprise policy level). You can enable the Permission Viewer by double-clicking the Permission value in the right pane.

Figure 18-17: Using the .NET Framework Configuration tool to view the contents of the Everything permission set (within the Enterprise policy level)

Figure 18-18: Using the .NET Framework Configuration tool to view the Enterprise policy level code group information

Figure 18-19: Preparing to view the properties of the Microsoft_Strong_Name child Code group in the Machine policy level

Figure 18-20: The General tab on the code group Properties window

Figure 18-21: The current Membership Condition setting for the Microsoft_Strong_Name child code group

Figure 18-22: The list of Membership Condition choices for a code group

Figure 18-23: The default Permission Set setting for the Microsoft_Strong_Name child code group

Figure 18-24: The Permission Set choices as shown in the code group Properties page

Chapter 19: Using Enterprise Services (COM+)

Figure 19-1: Launching the Component Services console

Figure 19-2: The Component Services console exposes the COM+ Applications node.

Figure 19-3: The System Application COM+ application as seen in the Component Services console

Figure 19-4: The Component Services console window shows the installed components in the right pane.

Figure 19-5: The Component Services console window with the Show/Hide Console Tree option enabled. You can use the Show/Hide Console Tree icon, located fourth from the left on the toolbar, to toggle this option. The Status view icon has been clicked to show the Status view of the components.

Figure 19-6: The Running Processes node in the Component Services console window

Figure 19-7: The VS .NET New Project window with the Class Library project template selected

Figure 19-8: Adding a reference for System.EnterpriseServices with the VS .NET IDE Component Selector window

Figure 19-9: Using the Visual Studio .NET Command Prompt window to create a strong name key (.snk) file

Figure 19-10: Adding the .snk file assembly-level attribute setting

Figure 19-11: A new COM+ application for the MyFirstClassLibraryVB sample serviced component. For demonstration purposes, I have expanded a few of the nodes for the COM+ application.

Figure 19-12: Using the regsvcs /? command syntax option to display the full list of options

Figure 19-13: Using the regasm /? command syntax option to display the full list of options

Figure 19-14: Using the regasm command and the /regfile command-line switch to generate a registry script. The file will be saved at C: \MyFirstClassLibraryVB.reg.

Figure 19-15: Viewing the C: \MyFirstClassLibraryVB.reg file with Notepad

Figure 19-16: Using the Component Services console to manually add a new COM+ application

Figure 19-17: Beginning the COM+ application installation

Figure 19-18: Choosing to create an empty COM+ application

Figure 19-19: Choosing the "Library application" option

Figure 19-20: The last prompt in the COM+ Application Install Wizard. You can potentially see other prompts depending on the choices you made in earlier wizard prompts.

Figure 19-21: Two new COM+ applications, one for each sample application

Figure 19-22: Launching the COM+ Component Install Wizard

Figure 19-23: The Welcome screen for the Component Install Wizard

Figure 19-24: Choosing the "Install new components" option

Figure 19-25: The type library and serviced component (modified class library) information is exposed in the COM+ Component Install Wizard.

Figure 19-26: The components have been installed into the two COM+ applications.

Figure 19-27: Accessing the component-level Properties page

Figure 19-28: The Properties page's General tab

Figure 19-29: Using the Properties page's Transactions tab to change the transaction support level

Figure 19-30: The Solution Explorer window shows the addition of references.

Figure 19-31: The client application is ready for use.

Figure 19-32: Viewing the Running Processes folder/node in the Component Services console window

Figure 19-33: Drilling down with the Running Processes folder/node in the Component Services console window

Figure 19-34: Using the Properties page Activation tab to enable the Object Pooling feature

Figure 19-35: The COM+ application Properties page's Queuing tab enables the COM+ Queued Components feature.

Figure 19-36: The MSMQ snap-in as seen in the Computer Management console. Notice the private queues that COM+ has created for your sample queued component.

Chapter 20: Developing for the Enterprise

Figure 20-1: Application flow for the MyMSMQExampleCOBOL and MyMSMQExampleVB sample applications

Figure 20-2: Accessing the VS .NET IDE Server Explorer window

Figure 20-3: The VS .NET IDE Server Explorer window showing the Message Queues node and nodes for several other server products

Figure 20-4: Preparing to create a new MSMQ private queue

Figure 20-5: Entering the name for the new private queue

Figure 20-6: The new myMSMQexample private queue is ready for use.

Figure 20-7: The MyMSMQExampleVB project showing the myMSMQexample MSMQ private queue in the VS .NET components tray with the default name of MessageQueue1

Figure 20-8: The MyMSMQExampleCOBOL project showing the myMSMQexample MSMQ queue in the VS .NET components tray with the default name of MessageQueue1

Figure 20-9: A portion of the VS .NET Help text for the System.Data.Dataset class. Many other .NET Framework classes are serializable, and you can also create your own serializable classes.

Figure 20-10: After executing the MyMSMQExampleCOBOL sample application

Figure 20-11: The myMSMQexample private MSMQ queue with one message

Figure 20-12: After executing the MyMSMQExampleVB sample application

Figure 20-13: The message box logic is coded as part of the exception-handling response.

Figure 20-14: Refreshing the MSMQ Queue display from the VS .NET Server Explorer window

Figure 20-15: The application flow of the MSMQ/asynchronous processing demonstration

Figure 20-16: The GUI/Design view of the MyMSMQAsyncAndTriggerCOBOL sample project

Figure 20-17: The GUI/Design view of the MyMSMQAsyncAndTriggerVB sample project

Figure 20-18: The MyMSMQAsyncAndTriggerCOBOL sample application reflects the GUID of each message sent to the MSMQ private queues.

Figure 20-19: Using the Computer Management console to view the MSMQ private queues and to manually purge the accumulated messages

Figure 20-20: A side-by-side display of each sample application and the resulting message box during one phase of the preliminary unit testing

Figure 20-21: Place the sample executables in the C: \MSMQ-ASYNC-DEMO to simplify the demonstration path displays.

Figure 20-22: The Message Queuing Triggers node as shown in the Computer Management Console window

Figure 20-23: Preparing to create a new MSMQ rule

Figure 20-24: Naming and describing the new MSMQ rule

Figure 20-25: Adding conditions for your MSMQ rule

Figure 20-26: Specifying the standalone executable choice. Also, the "Interact with desktop" option is checked.

Figure 20-27: Preparing to initiate the MSMQ trigger creation prompts

Figure 20-28: Entering the name for the new MSMQ trigger

Figure 20-29: Attaching the MSMQ rule to the MSMQ trigger

Figure 20-30: Viewing the Windows Task Manager's Processes tab. For demonstration purposes, I have executed the recent MSMQ sample applications.

Figure 20-31: The thread safety notice for the String class

Figure 20-32: The thread safety notice for the Dataset class

Figure 20-33: The thread safety notice for the Array class

Figure 20-34: The thread safety notice for the Array.SyncRoot property

Figure 20-35: The thread safety notice for the ArrayList class

Figure 20-36: The thread safety notice for the wrapper method ArrayList.Synchronized

Figure 20-37: The sample .NET Windows application MyThreadingExampleVB

Figure 20-38: Executing the sample .NET Windows application MyThreadingExampleVB. The worker thread has not been started.

Figure 20-39: Executing the sample .NET Windows application MyThreadingExampleVB. The worker thread has been started. Notice that the Label control is being updated.

Figure 20-40: Adding performance counters

Figure 20-41: The Explain Text window

Figure 20-42: The Performance window showing activity for the sample application

Figure 20-43: Adding all counters for the Thread performance object

Figure 20-44: The Performance window showing more activity for the sample application

Figure 20-45: Placing a debug breakpoint

Figure 20-46: Launching the VS .NET Threads window

Figure 20-47: Viewing the VS .NET Threads window

Figure 20-48: The VS .NET Disassembly window

Figure 20-49: Viewing the VS .NET Registers window

Figure 20-50: Viewing a VS .NET Memory window

Appendix A: Debugging and Testing

Figure A-1: The two components on the design surface of the ProjectInstaller.vb file

Figure A-2: Using the Services MMC snap-in to start the MyFirstWindowsService Windows Service

Figure A-3: Accessing the Event Viewer tool to view the application event log entries

Figure A-4: Using the Windows Task Manager to view the active processes

Figure A-5: Proceeding to debug an active process

Figure A-6: Attaching to the MyFirstWindowsService process

Figure A-7: The Attach to Process window

Figure A-8: Forcing a break into the attached process

Figure A-9: Viewing the forced break in the Sub Main procedure of the MyFirstWindowsService Windows Service process

Figure A-10: Manually placing a debugging breakpoint

Figure A-11: The MyFirstWindowsService Windows Service process in break mode

Figure A-12: The Add New Project dialog box showing the ACT Project template

Figure A-13: The Add New Item dialog box showing the three default templates

Figure A-14: Ready to start recording with the Browser Record dialog box

Figure A-15: Preparing to end the browser recording

Figure A-16: Starting the ACT test from within VS .NET

Figure A-17: Stopping the ACT test from within VS .NET

Figure A-18: The VS .NET Output window showing the ACT test results for the sample application WebApplicationSampleVB

Figure A-19: The Performance Monitor

Figure A-20: The ACT stand-alone product

Figure A-21: Viewing an existing ACT project and existing ACT test script in the ACT stand-alone product

Figure A-22: Preparing to run the existing ACT test script for the WebApplicationSampleVB sample application

Figure A-23: Viewing the Graph tab on the ACT Test Status window