VB6 UML : design and development / Jake Sturm.

By:

Sturm, Jake

Material type: Text

TextSeries: Programmer to programmerPublication details: Acocks Green, UK : Wrox, c1999.Description: xiii, 581 p. : ill. ; 24 cmISBN:

1861002513 (pbk.) :

Subject(s):

DDC classification:

005.2768 STU

Holdings
Item type	Current library	Call number	Copy number	Status	Date due	Barcode
Standard Loan	Moylish Library Main Collection	005.2768 STU (Browse shelf(Opens below))	1	Available		39002000387267

Enhanced descriptions from Syndetics:

UML (Unified Modelling Language) is a powerful notational approach to object-oriented analysis, design and implementation. If you understand and can utilize UML, your object-oriented Visual Basic programming becomes much more logical and effective. UML allows you to design, plan and implement great Visual Basic programs. The ease of learning the fundamentals of Visual Basic often misleads VB programmers. Object-oriented programming, and UML in particular, empowers VB programmers with a system of thinking, designing and implementing their programs in a more professional, robust manner. This textbook is a guide to this complex subject.

Includes index.

Table of contents provided by Syndetics

Introduction (p. 1)
What's Covered in This Book (p. 2)
What You Need to Use This Book (p. 3)
Conventions Used (p. 3)
Source Code (p. 4)
Tell Us What You Think (p. 4)
Chapter 1 Introducing the Unified Modeling Language (p. 7)
What UML Is (and what it is not) (p. 8)
A Brief History of UML (p. 8)
What Exactly is a Model? (p. 9)
Why Use UML? (p. 9)
UML: The Key to Success (p. 10)
The Project Development Process (p. 11)
A Whirlwind Tour of UML (p. 11)
UML Diagrams (p. 12)
Use Case Models (p. 12)
Interaction Diagrams (p. 14)
Class Diagrams (p. 16)
Activity Diagrams (p. 17)
Other Diagrams (p. 18)
The UML Process (p. 18)
VB and UML (p. 20)
Is Visual Basic an Object-Oriented Language? (p. 20)
Do Visual Basic Projects Really Need UML? (p. 21)
My Approach (p. 22)
A Real-World Project (p. 22)
Summary (p. 23)
Chapter 2 Project Design and Management (p. 25)
Designing a Project (p. 26)
Standards (p. 27)
Frameworks (p. 27)
Choosing Frameworks (p. 28)
Patterns (p. 29)
Finding Your Own Patterns (p. 30)
Why Are Patterns So Useful? (p. 30)
The Northwind Project (p. 31)
Choosing the Frameworks (p. 32)
Working with these Frameworks (p. 34)
Patterns Used in the Project (p. 35)
The Project Development Lifecycle (p. 36)
The Enterprise Application Model (p. 36)
Project Management (p. 37)
Part 1 Project Design (p. 39)
Documentation of Specifications Prior to Writing Code (p. 39)
A Graphical User Interface (GUI) Prototype (p. 40)
Documentation of Risks (p. 40)
Maintaining a Library (p. 42)
Part 2 Project Implementation (p. 42)
Build the Project Incrementally and with Components (p. 43)
Testing Frequently and Documenting All Bugs and Changes (p. 44)
Careful Design of all Components (p. 46)
Summary (p. 47)
Chapter 3 Requirements Development (p. 49)
Relationships (p. 50)
Dependency (p. 50)
Association (p. 50)
Aggregation (p. 51)
Composite Aggregation (p. 52)
Generalization (p. 53)
Actors (p. 54)
Identifying Actors (p. 54)
UML Representation of Actors (p. 55)
Interviewing Users (p. 55)
Interview with the Sales Representative (p. 56)
Making Sense of Interviews (p. 58)
Summary of the Interview (p. 58)
The Actor Creates an Order (p. 58)
The Actor Modifies Customer Information (p. 58)
The Actor Creates a New Customer (p. 59)
Other Information (p. 59)
The Use Case (p. 59)
Use Case Criteria (p. 60)
How to Build a Use Case (p. 60)
Trying It Out - Building Use Cases (p. 61)
Use Case: Create a New Customer - A Step-By-Step Guide (p. 61)
Use Case: Modify a Customer (p. 64)
Use Case: Create an Order (p. 66)
Interview with the Sales Manager (p. 67)
Summary of Interview with the Sales Manager (p. 68)
Actor Deletes Customers (p. 68)
Actor Deletes Orders (p. 69)
Actor Edits an Order (p. 69)
Other Information (p. 69)
Use Case: Delete Customer (p. 69)
Use Case: Delete Order (p. 71)
Use Case: Modify Order (p. 72)
Summary of Interview with the Inside Sales Coordinator (p. 73)
Use Case Diagrams (p. 74)
Creating a Use Case Diagram - A Step-By-Step Guide (p. 75)
The Sales Representative (p. 75)
Use Cases Stereotypes (p. 79)
The [[uses]] StereoType (p. 79)
The [[extends]] Stereotype (p. 81)
Reviewing Use Case Models (p. 85)
We've Made Our Use Cases; What Next? (p. 86)
Identifying Objects from the Use Cases (p. 86)
Identifying Objects: A Step By Step Guide (p. 87)
Why Identify Objects from Uses Cases? (p. 89)
This is Just the Beginning (p. 90)
Summary (p. 90)
Chapter 4 Interaction Diagrams (p. 93)
What is an Interaction Diagram? (p. 94)
Sequence or Collaboration: Which is Best? (p. 94)
Sequence Diagrams (p. 95)
Sequence Diagrams: A Quick Primer (p. 96)
Building A Sequence Diagram - A Step-By-Step Guide (p. 98)
Create New Customer Sequence (p. 98)
Modify Customer Sequence Diagram (p. 109)
Delete Customer Sequence Diagram (p. 111)
Order Sequence Diagrams (p. 112)
Product Sequence Diagrams (p. 113)
Why Use Sequence Diagrams? (p. 118)
Finding Patterns in our Sequence Diagrams (p. 119)
How Can We Take Advantage of Patterns? (p. 119)
How Detailed Should Sequence Diagrams Be? (p. 121)
Collaboration Diagrams (p. 123)
Collaboration Diagrams: A Primer (p. 123)
Building Collaboration Diagrams - A Step-By-Step Guide (p. 124)
Create New Customer Collaboration (p. 124)
Modify Customer Collaboration Diagram (p. 130)
Why Use Collaboration Diagrams? (p. 131)
Summary (p. 131)
Chapter 5 Class Diagrams (p. 133)
What is a Class Diagram? (p. 134)
Class Types (p. 135)
Business Entity Objects (p. 136)
Business Service Objects (p. 136)
System Entity Objects (p. 136)
System Service Objects (p. 136)
Identifying Classes (p. 136)
Associations Between Classes (p. 138)
Ordinary Associations (p. 138)
Inheritance (p. 138)
Aggregation (p. 138)
Deriving Class Properties (p. 139)
Business Rules (p. 139)
Requirement Business Rules (p. 140)
Definition Business Rules (p. 140)
Factual Business Rules (p. 140)
Constraint Business Rules (p. 140)
Derivation Business Rules (p. 140)
Implementing Business Rules (p. 141)
The Business Rules for Create New Customer (p. 141)
Why Use Business Rules? (p. 145)
Creating the Associated Business Rules (p. 145)
The Class Diagram for Customer (p. 152)
The Northwind System Class Diagram (p. 152)
Roles: 'Has' and 'Is A Part Of' (p. 153)
Cardinality (p. 154)
The Products/Orders Association (p. 154)
The Orders/Employees Association (p. 154)
The Orders/Customer Association (p. 154)
Summary of the Northwind System Class Diagram (p. 154)
Deriving Class Methods (p. 155)
Customer Class Methods (p. 156)
Product Class Methods (p. 159)
A Pattern: Customer and Product Class Diagrams (p. 161)
Class Hierarchies and Patterns (p. 161)
Summary (p. 162)
Chapter 6 Prototyping the GUI (p. 165)
Form Control (p. 165)
Order Entry GUI (p. 166)
Building the Order Entry Sequence Diagram (p. 166)
How Not to Make a GUI (p. 168)
Actors and Use Case Focused Forms (p. 169)
Using Tabs (p. 170)
Putting It All Together (p. 171)
Are Two Forms Better Than One? (p. 172)
Security (p. 173)
Internet Applications (p. 173)
A Form in Many Guises (p. 173)
Delete Customer GUI (p. 174)
The GUI Effect (p. 176)
Summary (p. 176)
Chapter 7 External and Internal Factors (p. 179)
Review of the UML Process (so far) (p. 180)
Use Cases (p. 180)
Interaction Diagrams (p. 180)
Activity Diagrams (p. 181)
GUI Prototype (p. 181)
The Iterative Process (p. 181)
Where We Are Right Now (p. 182)
What Next? (p. 182)
How UML Fits In: Activity Diagrams (p. 182)
Chapter 8 Frameworks and Technologies (p. 185)
Review of our Technical Requirements (p. 186)
Client-Server Architecture (p. 186)
Distributed iNternet Applications (DNA) (p. 187)
The Middle-Tier (p. 188)
Building with Components (p. 188)
ActiveX Data Objects (ADO) (p. 189)
Using ADO (p. 189)
The Connection Object (p. 190)
The Command Object (p. 190)
The Recordset Object (p. 191)
ADO and DNA (p. 191)
Remote Data Services (RDS) (p. 191)
The Components of an RDS Project (p. 194)
Security (p. 194)
Stateless Transactions (p. 195)
Visual Basic Data Providers (p. 195)
Data Source Classes as Data Providers (p. 195)
Visual Basic Class Hierarchy Framework (p. 196)
Information Flow in a Class Hierarchy (p. 196)
The Four Rules of Visual Basic Class Hierarchies (p. 196)
Class Hierarchy Rule 1 (p. 197)
Class Hierarchy Rule 2 (p. 197)
Class Hierarchy Rule 3 (p. 198)
Class Hierarchy Rule 4 (p. 198)
Fitting Our UML Design Into the Frameworks (p. 198)
Architectural Views (p. 199)
Building Three-Tier Visual Basic Components (p. 200)
Placing the Server Component (p. 200)
Client-Side Components (p. 201)
Distributing the Objects (p. 201)
Client Size and State (p. 202)
Implementing a Class Hierarchy (p. 202)
CRC Cards (p. 204)
Properties in the Data Provider Managed Class (p. 207)
Synchronizing the Middle and Bottom Classes (p. 208)
Catastrophic and Harmless Problems (p. 209)
Placing the Recordset (p. 211)
Putting It All Together (p. 211)
Summary (p. 212)
Chapter 9 Designing A Test Project With Activity Diagrams (p. 215)
Activity Diagrams (p. 216)
The Parts of an Activity Diagram (p. 216)
Designing a Test Project (p. 219)
The Test Server Component (p. 220)
Activity Diagrams in Action (p. 220)
Building Activity Diagrams: Retrieve Customer (p. 221)
Benefits of Activity Diagrams (p. 226)
Mapping and Reviewing Methods (p. 226)
Finding Patterns (p. 226)
Activity Diagram: Retrieve Product (p. 227)
Activity Diagram: Retrieve Category (p. 229)
Taking Advantage of Patterns (p. 229)
Efficient and Effective Testing (p. 231)
Summary (p. 233)
Chapter 10 Building and Testing A Server-Object (p. 235)
Building the Experimental Server Object (p. 236)
Connecting to the Database (p. 236)
Retrieving Categories Recordset (p. 241)
Retrieving Products Recordset (p. 244)
Updating the Recordset in the Database (p. 246)
UpdateProduct (p. 248)
Reconciling Product Inconsistencies (p. 251)
GetServerTime Function (p. 255)
Compiling the Server Object (p. 256)
Registering the Server Object (p. 257)
The Client-Side Component (p. 259)
Building the Client Component (p. 260)
The Login Form (p. 261)
The Test Form (p. 263)
Running the Test Project (p. 274)
Summary (p. 275)
Chapter 11 Building The Final Server Object With MTS (p. 279)
Microsoft Transaction Server (MTS) (p. 280)
Scaling Our Components with MTS (p. 281)
Object Life Times Under MTS (p. 281)
Resource Pooling (p. 281)
Managing Transactions (p. 281)
MTS and Database Transactions (p. 282)
Non-Transactional Objects (p. 283)
Security Under MTS (p. 283)
A Stateless Programming Model (p. 283)
MTS and Visual Basic (p. 284)
Creating MTS Objects with Visual Basic (p. 284)
Making Objects Support Transactions (p. 285)
Building the Revised Server Object (p. 286)
Setting the Project Up (p. 286)
Adding the Declarations (p. 287)
Coding for MTS (p. 289)
Coding the ObjectControl Interface (p. 290)
Methods For the MTS Object Context Properties (p. 291)
A Generic CreateInstance Function (p. 291)
The Generic SetComplete and SetAbort Methods (p. 292)
Working with the ADO Connection Object (p. 292)
Revisiting the Test ADOConnection Function (p. 292)
Making the ADO Connection (p. 292)
Retrieving the ADO Connection Object (p. 294)
Closing the ADO Connection Object (p. 294)
Validating UserID and Password (p. 295)
Retrieving a Recordset (p. 299)
Creating the Generic GetRecordset Method (p. 300)
Creating the Function to Return a Products Recordset (p. 302)
Creating the Function to Retrieve a Customer Recordset (p. 304)
Creating the Other Get Functions (p. 305)
Updating the Database (p. 306)
A Generic Update Method (p. 307)
Creating the UpdateCustomer Function (p. 309)
Updating Products (p. 312)
Updating Products Directly (p. 315)
Product Updates from Adding an Order (p. 324)
Creating the UpdateOrders Method (p. 329)
Creating a New Order (p. 331)
Creating a Sub to Submit an Order (p. 332)
Summary (p. 334)
Chapter 12 Coding the Customer Client Component (p. 337)
The Client Component Design (p. 338)
Setting Up the Customer Component (p. 338)
Adding a BAS Module (p. 339)
Adding a Resource File (p. 341)
Implementing The Bottom Class (p. 343)
Bottom Class: Coding the Class Events (p. 344)
Bottom Class: Validating Fields - Part One (p. 346)
Bottom Class: Validating Fields - Part Two (p. 349)
Bottom Class: Creating the Customer Object Properties (p. 352)
Bottom Class: EditMode Property (p. 362)
Bottom Class: Updating the Data Consumers (p. 363)
Implementing The Middle Class (p. 364)
Middle Class: Coding the Class Events (p. 367)
Middle Class: Getting Information From the Top Class (p. 369)
Middle Class: General Properties (p. 369)
Middle Class: Private Properties Related to the Database (p. 371)
Middle Class: Public Properties Related to the Database (p. 371)
Implementing The Top Collection Manager Class (p. 380)
Top Class: Coding the Class Events (p. 382)
Top Class: A Function to Retrieve the Customer Collection (p. 383)
Top Class: Refreshing All the Customer Collections (p. 384)
Summary (p. 385)
Chapter 13 Coding the Other Client Components (p. 387)
Implementing the OrderDetails Component (p. 387)
OrderDetails: basODMain (p. 388)
OrderDetails: Middle Class - OrderDetailManager (p. 389)
OrderDetails: Middle Class - The Update Method (p. 390)
OrderDetails: Middle Class - The Scope of ItemsRecordset (p. 392)
OrderDetails: Bottom Class - OrderDetail (p. 392)
OrderDetails: Bottom Class - Properties that are the Same (p. 393)
OrderDetails: Bottom Class - Properties that are Different (p. 393)
OrderDetails: Bottom Class - The Class Events (p. 399)
OrderDetails: Bottom Class - The ValidateFields Method (p. 399)
OrderDetails: Bottom Class - Coding the Other Methods (p. 400)
OrderDetails: Top Class - cltOrderDetails (p. 401)
OrderDetails: Top Class - The Declarations Section (p. 401)
OrderDetails: Top Class - The UserControl Events (p. 402)
OrderDetails: Top Class - The OrderIDEquals Property (p. 402)
OrderDetails: Top Class - The GetOrderDetailsCollection Method (p. 403)
OrderDetails: Top Class - The ChangeManagedObjects Method (p. 403)
OrderDetails: Top Class - The ChangeManagedObjects Event (p. 403)
Implementing the Order Component (p. 404)
Order: basOMain (p. 404)
Order: Middle Class - OrderManager (p. 405)
Order: Middle Class - Changing the SetProxyInformation Method (p. 406)
Order: Middle Class - The Update Method (p. 407)
Order: Middle Class - The UpdateOrderOrderDetail Method (p. 408)
Order: Bottom Class - Order (p. 408)
Order: Bottom Class - Order Properties (p. 409)
Order: Bottom Class - Coding the ValidateFields Method (p. 419)
Order: Bottom Class - Routines that are the Same (p. 420)
Order: Top Class - ctlOrders (p. 423)
Order: Top Class - The UserControl Methods (p. 423)
Order: Top Class - OrderIDEquals Property (p. 423)
Order: Top Class - The ChangeManagedObjects Event (p. 424)
Order: Top Class - The ChangeManagedObjects Method (p. 424)
Order: Top Class - The GetOrderCollection Method (p. 424)
Implementing the Product Component (p. 425)
Product: basPMain (p. 426)
Product: Middle Class - ProductManager (p. 426)
Product: Middle Class - The Update Method (p. 428)
Product: Middle Class - The Find Method (p. 429)
Product: Bottom Class - Product (p. 429)
Product: Bottom Class - Product Properties (p. 430)
Product: Bottom Class - The ValidateFields Method (p. 436)
Product: Bottom Class - Routines that are the Same (p. 437)
Product: Top Class - cltProducts (p. 439)
Product: Top Class - The UserControl Events (p. 440)
Product: Top Class - The ChangeManagedObjects Event (p. 440)
Product: Top Class - The ChangeManagedObjects Method (p. 440)
Product: Top Class - The GetProductCollection Method (p. 441)
Product: Top Class - The CategoryIDEquals Property (p. 441)
Summary (p. 441)
Chapter 14 Creating the GUI Order Form (p. 443)
Building the GUI Form (p. 443)
The Customers Frame (p. 444)
The Products and Categories Frame (p. 446)
The Order Details Frame (p. 447)
Adding the Client Components (p. 447)
The Completed Form (p. 448)
The Code Behind the Form (p. 449)
The Initialize Routine (p. 449)
The Click Events (p. 454)
The Combo Boxes (p. 454)
The Command Buttons (p. 456)
Summary (p. 464)
Chapter 15 Testing and Quality Control (p. 467)
Different Levels of Testing (p. 467)
When to Use Each Level of Testing (p. 468)
Quality Control (p. 468)
Creating Component Test Modules (p. 470)
Building a Test Module for the Customer Component (p. 470)
Testing the Bottom Customer Object (p. 477)
Summary (p. 477)
Chapter 16 What Comes Next? (p. 479)
Overview (p. 479)
Using UML (p. 480)
The DNA Framework (p. 480)
The Next Steps (p. 481)
Improving the System (p. 482)
Testing the System (p. 482)
More than One Release? (p. 482)
Appendix A UML to VB Mapping (p. 485)
Purpose of the VB Mapping (p. 485)
UML Version Covered (p. 485)
How the Mapping is Structured (p. 485)
How Well Does the UML Map to VB? (p. 486)
UML and Components (p. 486)
Concrete Or By Convention? (p. 486)
Upgrade to at Least VB5 (p. 487)
Styles Used in the Mapping (p. 487)
How to Use this Mapping (p. 487)
Building Your Diagrams (p. 487)
Mapping Guide (p. 488)
1.0 General Extension Mechanisms (p. 490)
1.1 Constraints and Comments (p. 490)
1.2 Element Properties (p. 490)
1.3 Stereotypes (p. 491)
2.0 Model Management (p. 491)
2.1 Packages (p. 492)
3.0 Static Structure Diagrams (p. 494)
4.0 Classifiers (p. 495)
4.1 General (p. 495)
4.2 Interfaces (p. 499)
4.3 Attributes (p. 500)
4.4 Operations (p. 501)
4.5 Utilities (p. 503)
4.6 Associations (p. 504)
5.0 Use Case Diagrams (p. 523)
5.1 A Word of Warning (p. 524)
5.2 Use Cases and Transactions (p. 524)
5.3 Use Cases and Controllers (p. 524)
6.0 Behavioral Diagrams (p. 525)
7.0 Sequence and Collaboration Diagrams (p. 525)
7.1 Object Instances and Context (p. 526)
7.2 Interactions (p. 527)
7.3 Pseudo-Code (p. 527)
7.4 Collaboration Diagrams (p. 527)
8.0 Statechart Diagrams (p. 528)
8.1 Mapping States and Transitions (p. 528)
8.2 Implementing State (p. 528)
8.3 An Example (p. 529)
8.4 Implicit Implementation (p. 530)
8.5 Explicit Implementation: A Finite State Machine (p. 532)
9.0 Activity Diagrams (p. 536)
10.0 Implementation Diagrams: Component and Deployment Diagrams (p. 537)
10.1 UML Components and Visual Basic (p. 538)
10.2 Logical components (p. 538)
10.3 Physical Components (p. 539)
10.4 Stereotypes (p. 540)
Appendix B Adding Keys to the Registry (p. 543)
Appendix C Using MTS (p. 547)
Hosting a DLL in MTS (p. 547)
Installing a New Package (p. 548)
Exporting a Package (p. 552)
Debugging an MTS DLL With Visual Basic (p. 554)
Setting Up a Database (p. 555)
Coding For Debugging (p. 556)
Switching Debugging On (p. 558)
Appendix D Fine Tuning Visual Basic Components Running Under MTS (p. 561)
MTS Performance Issues for Open Connections (p. 561)
VB Code That Works With And Without MTS (p. 563)
Debugging an MTS Visual Basic Component (p. 563)
MTS Transaction Statistics (p. 564)
Index (p. 568)