A Programmer's Introduction to Windows DNA

by Gross, Christian

• ISBN13: 9781893115170
• ISBN10: 1893115178
• Edition: CD
• Format: Paperback
• Copyright: 2000-05-01
• Publisher: Springer-Verlag New York Inc

Summary

Windows DNA is Microsoft's "client-server architecture" for the era of the Internet, addressing the full spectrum of enterprise application development. This is the first book designed to help Windows developers decide not only which Windows DNA technologies to use but how to use them.

Table of Contents

Introduction	xiii
Examples, Languages, and Source Code	v
Acknowledgments	xv
Introduction to Windows DNA	1	(22)
The Importance of Context	1	(3)
DOS---The First Era	2	(1)
Windows 3.x---The Second Era	2	(1)
Windows 32-Bit---The Third Era	2	(1)
Windows DNA---The Fourth Era	3	(1)
The Windows DNA Strategy	4	(1)
The Guiding Principles of Windows DNA	4	(1)
The Architecture of Windows DNA	5	(11)
COM Everywhere	6	(1)
Presentation Tier	6	(3)
Firewall	9	(1)
Business Logic Tier	10	(4)
Data Tier	14	(2)
Writing Applications Using Visual Studio	16	(5)
The Context of a Random Language	16	(1)
Programming Languages in Visual Studio	17	(3)
Enterprise Features	20	(1)
Putting It in Perspective	21	(2)
All About Patterns	23	(8)
An Introduction to Patterns	23	(1)
A Simple Pattern Example	23	(1)
Where the Pattern Fails	24	(1)
Understanding Patterns	24	(4)
Defining a Good Pattern	24	(1)
Types of Patterns	25	(1)
Template for Describing Patterns	26	(2)
Relating Patterns to Other Concepts	28	(1)
Antipatterns	28	(1)
Why Antipatterns Evolve	28	(1)
Putting It in Perspective	29	(2)
Designing Your Application	31	(26)
Developing Applications	31	(8)
The Application Development Cycle	31	(1)
The Waterfall Model	32	(1)
Dangers in Implementing an Application	33	(1)
The Solution: Iterative Contextual Design	34	(5)
Starting with a Project	39	(16)
To Build a Framework or Not?	39	(1)
Some Background Information	39	(2)
Application Requirements	41	(3)
Defining the Application	44	(7)
Defining the Model Details	51	(4)
Putting It in Perspective	55	(2)
Building a Prototype	57	(18)
Components	57	(12)
A Bit of Component History	57	(3)
Components---The Design Concept	60	(2)
Interfaces and Implementations	62	(6)
Some Component Examples	68	(1)
Building Prototypes	69	(5)
What Is a Good Prototype?	69	(1)
What Features to Implement	70	(1)
Determining the First Line of Code	71	(1)
Coding Standards	71	(3)
Putting It in Perspective	74	(1)
Creating the Thin Client	75	(22)
The Web Interface	75	(8)
Navigation	75	(3)
Web Site Activities	78	(1)
The Thin Client User Interface	79	(1)
HTML 4.0 Defined	79	(1)
Web Accessibility	80	(1)
The First HTML Page	80	(1)
Filling the Web Page with Content	81	(2)
Processing HTML Pages for the Thin Client	83	(13)
An Overview of ASP	83	(2)
A Quick Script Example	85	(1)
ASP Applications	86	(4)
Processing HTML Forms	90	(2)
The CGI Call	92	(1)
The Server Side	93	(2)
Data Validation	95	(1)
Putting It in Perspective	96	(1)
Creating a Rich Client	97	(32)
Why an HTML Client?	97	(1)
The Simplicity of HTML	97	(1)
The Dynamism of HTML	98	(1)
Structuring Your Document	98	(9)
The Elements of a Page	98	(1)
Designing a Look for Your Document	99	(7)
Understanding Your Data	106	(1)
The Browsing Client	107	(11)
Introduction to XML	107	(4)
XSL	111	(7)
The Workhorse Client	118	(9)
Working with the DOM	118	(3)
Handling the Mouse	121	(3)
Writing Scripting Code	124	(3)
Putting It in Perspective	127	(2)
Building a Web Application	129	(30)
Building Server-Side Logic	129	(2)
To Use a Cookie or Not	129	(1)
Moving the Data	129	(1)
A Bit More about ASP	130	(1)
Building the Web Application	131	(19)
Detecting Browser Capabilities	131	(3)
Returning the Correct Web Page	134	(3)
Language Support	137	(1)
Building the Body	138	(2)
The Visual InterDev Scripting Library	140	(10)
Putting It All Together	150	(7)
Where to Start?	150	(1)
Designing and Implementing the Pieces	151	(6)
Putting It in Perspective	157	(2)
Designing COM Interfaces	159	(28)
Thinking with Interfaces	159	(2)
Developing an Architecture	159	(2)
Building a COM Component	161	(9)
How COM Works	161	(1)
IDL and What It Does	162	(3)
A COM Package	165	(1)
The COM Interface	166	(4)
Some COM Interface Design Techniques	170	(16)
Interfaces Are Immutable	170	(2)
When an Interface Must Be Extended	172	(2)
Using a Programming Language to Develop COM Interfaces	174	(12)
Putting It in Perspective	186	(1)
Implementing COM Interfaces	187	(34)
Understanding the Dynamics of Implementing Components	187	(2)
Separating Data Gathering, Data Operations, and Data Checking	188	(1)
An Example Set of Interfaces	189	(9)
Extending the Interfaces with Multiple Data and Operation Classes	191	(1)
Registering the Type Library	191	(1)
Implementing the Interfaces Using Visual Basic	191	(3)
Implementing the Interfaces Using Visual J++	194	(3)
Implementing the Interfaces Using Visual C++	197	(1)
Some Concluding Remarks	198	(1)
Writing Implementations	198	(6)
Using UML	199	(1)
Writing Components Using UML	200	(4)
Consuming COM Classes	204	(9)
Consuming COM Classes Using Visual Basic	204	(2)
Consuming COM Classes Using Visual J++	206	(1)
Consuming COM Classes Using Visual C++	207	(6)
Handling Errors	213	(7)
COM Errors	213	(2)
How to Generate Errors	215	(1)
Using Error Handling in Visual Basic	216	(2)
Using Error Handling in Visual J++	218	(1)
Using Error Handling in Visual C++	219	(1)
Putting It in Perspective	220	(1)
Developing Transactional Components	221	(28)
Introducing Transactions	221	(8)
ACID: The Four Commandments of Transaction Processing	222	(2)
Types of Transactions	224	(1)
Two-Phase Commit	225	(1)
COM+ Applications	226	(3)
A Good Transactional COM+ Object	229	(7)
A Bit of History	230	(1)
State-Managed Objects	231	(5)
Writing Transactional Components	236	(11)
How to Declare a COM+ Transactional Object	236	(6)
Multiple COM+ Object Transaction Scenarios	242	(2)
Getting the Transaction Interface	244	(1)
Changing the Outcome of the Transaction	245	(2)
Converting a COM Object to COM+	247	(1)
Putting It in Perspective	248	(1)
Developing Messaging COM+ Objects	249	(36)
Introduction to MSMQ	249	(15)
MSMQ API and the MSMQ ActiveX Component	250	(1)
Comparison of DCOM and MSMQ	250	(1)
Experimenting with MSMQ Using the API Testing Sample	251	(7)
Message Attributes	258	(6)
Writing a Messaging Application	264	(19)
A Solution to Messaging	264	(2)
Writing an Implementation	266	(7)
An Example of Distributed Application	273	(10)
Putting It in Perspective	283	(2)
COM+ Asynchronous Services	285	(30)
COM+ Queued Components	285	(10)
How Queued Components Work	285	(1)
Implementing a Queueable COM+ Component	286	(5)
Instantiating a Queueable COM+ Component	291	(2)
And if Something Goes Wrong	293	(2)
Getting an Answer Back	295	(1)
COM+ Event Services	295	(18)
Building a Publisher/Subscriber Application	297	(8)
Filtering Events	305	(6)
Defining a Transient Subscriber	311	(2)
Transactions and COM+ Events	313	(1)
Putting It in Perspective	313	(2)
More COM+ Services Programming	315	(22)
Scalability and COM+ Lifetime Management	315	(7)
Implementing Object Pooling	315	(6)
Dynamic Load Balancing	321	(1)
More Transaction Management Interfaces	322	(6)
IContextState	322	(1)
IObjectContextInfo	322	(2)
Specifying Construction Parameters	324	(2)
Creating a Transaction Stream of Objects	326	(2)
ASP Component Object Development	328	(8)
A Simple ASP Page	328	(1)
Integrating a COM+ Object	329	(2)
An ASP COM+ Object	331	(3)
Transacted ASP Pages	334	(2)
Putting It in Perspective	336	(1)
Building the Hybrid Client	337	(32)
Defining the Hybrid Client	337	(3)
The Architecture of the Hybrid Client	338	(1)
Business Logic on the Client	339	(1)
Building a Corporate Desktop	340	(27)
Building the Shell	341	(11)
Building the Content	352	(15)
Putting It in Perspective	367	(2)
Building Your Resources	369	(36)
SQL and Portability	369	(1)
Why Not Use an OODBMS?	369	(1)
Which Version of Microsoft SQL Server?	370	(1)
SQL Basics	370	(15)
Tables	370	(8)
Why Use Stored Procedures?	378	(2)
Creating Simple Stored Procedures	380	(2)
Simple Table Manipulation with SQL	382	(3)
More SQL Techniques	385	(18)
Working with Variables	385	(1)
Searching with Dates	386	(1)
Searching with Wildcards	387	(1)
Advanced Data Manipulation	388	(3)
Programming in Transact SQL	391	(4)
Temporary Information and Cursors	395	(1)
Accessing System Information	396	(1)
Creating and Using Views	397	(1)
Working with Joins	398	(5)
Putting It in Perspective	403	(2)
Accessing the Data	405	(30)
Universal Data Access	405	(2)
Why Use UDA?	407	(1)
How to Access the Data	407	(2)
Read-Only Operations	408	(1)
Data-Modifying Operations	408	(1)
An Introduction to ADO	409	(19)
The Architecture of ADO	410	(1)
Performing Processing Data Operations	411	(4)
Performing Read-Only Operations	415	(8)
Record and Stream Objects	423	(1)
Records	423	(3)
Streams	426	(2)
Data Shaping with ADO	428	(5)
Using the Data-Shaping Provider	428	(1)
Coding a Shaped Command	429	(1)
Navigating the Data	429	(1)
Performing Computations	430	(1)
Embedding Multiple SHAPE Statements	431	(1)
Writing More Complex SHAPE Commands	432	(1)
Putting It in Perspective	433	(2)
Optimizing the Data Access Tier	435	(20)
OLE DB Consumer Template Classes	435	(3)
Connection Classes	437	(1)
Execution Classes	437	(1)
Viewing Classes	437	(1)
An OLE DB Consumer Template Example	438	(5)
Building the Template Class	438	(1)
Opening the Table	439	(2)
Testing the Classes	441	(2)
Calling Stored Procedures	443	(9)
Executing the Command	444	(1)
Using Multiple Accessors	445	(3)
More on COLUMN_ENTRY	448	(4)
Working with BLOB Data	452	(2)
Retrieving Bulk Records	454	(1)
Putting It in Perspective	454	(1)
Directory Services	455	(20)
Architecture of Microsoft Active Directory	455	(8)
Active Directory Object	455	(4)
A Practical Active Directory Example	459	(4)
Accessing the User with ADSI	463	(4)
Creating Custom Objects	467	(5)
Working with a Custom Active Directory Object	472	(1)
Using OLE DB and ADO	472	(2)
Querying Using the LDAP Notation	472	(2)
Querying Using the SQL Notation	474	(1)
Using ADO	474	(1)
Putting It in Perspective	474	(1)
The Quality Control Process	475	(30)
Defining the Quality Control Process	475	(6)
Defining a Metric	476	(1)
Tracking Bugs	477	(4)
Testing the Application	481	(11)
Defining a Testing Strategy	481	(4)
Building a Test Framework	485	(2)
Writing a Driver	487	(5)
Performance Testing	492	(12)
Testing the Hardware	493	(7)
Testing Results	500	(1)
Testing the Application with Visual Studio Analyzer	501	(3)
Putting It in Perspective	504	(1)
Creating Services	505	(18)
Running a 24x7 Process	505	(12)
Controlling a Service	505	(2)
Building a Service	507	(10)
Running a Batch Process	517	(5)
Using the Windows Scripting Host	517	(2)
Adding a Scheduled Task	519	(3)
The Final Perspective	522	(1)
Appendix A: Patterns Used in This Book	523	(10)
Bridge Pattern	523	(1)
Command Pattern	524	(1)
Data Abstraction Pattern	525	(1)
Facade Pattern	526	(1)
Layered Pattern	527	(2)
Remote Control Pattern	529	(1)
Separating Format from Logic Pattern	530	(3)
Appendix B: Source Code Description	533