Course Name: MTS/COM+ Performance and Tuning
Brief Course Description: Learn how to write MTS/COM+ applications correctly and understand the many pitfalls that can be encountered when developing these complex applications. Learn to apply performance
and tuning transactional techniques that result in dramatic throughput improvements.
Duration: 4 Full Days
Format: Instructor-led, hands-on
Prerequisites: Advanced knowledge of Visual Basic and Active Server Pages is assumed. Student should already be able to write an ActiveX DLL and use it on an Active Server Page.
Recommended Reading: Students should be comfortable in advance of attendance with the content in the following books:
VB6 BOOTCAMP Certification Exam Guide, Mezick; publisher McGraw-Hill
Professional Active Server Pages, Homer, Sussman, Francis; publisher Wrox Press
Assumed Audience: Advanced Visual Basic and ASP developers
Course Materials: MTS/COM+ Textbook, NewTech MTS/COM+ Resource Pack with CD
Resource pack contains the following:
- Source code listings
- Book lists with commentary and reviews
- Terminology grid, listing all pertinent terms in alphabetical order. All terms are linked, i.e., a term that refers to another term in the list is a link, allowing the user to view related terms in real time
- List of 3rd party add-ons and libraries that aid in building systems with this technology
- Web site listings related to this topic
- White papers written by NewTech consulting staff on this topic
- CD-ROM with additional resources for the developer using this technology
Course Description Summary: This comprehensive course on writing Windows DNA applications with MTS or COM+ is based upon the experience of NewTech's consultant's in the field.
Technologies such as MTS and COM+ are a moving target and the state of the art in best practices is continually advancing.
Many books in print are now obselete in the face of the facts. Many “experts” will claim they know how to write these
applications correctly, without applying their suggested techniques in the field. This course will allow
developers to write scalable, maintainable and therefore highly efficient
Windows DNA applications using techniques that represent the current state of
the art. This course covers not just how to write these applications but more importantly – what techniques to avoid
when writing these applications, and why. In addition this course also prepares the student for the migration to
the .NET platform with an introduction to SOAP with Visual Basic 6.0 and ASP as well as an overview of the discrepancies between VB 6.0 and VB.NET.
When the student leaves the course... he or she will have an excellent understanding of what it takes to successfully develop Windows DNA applications. By understanding exactly how MTS and COM+ Services function, students will be able to avoid making very costly design and coding errors that can bring an application of this type to its proverbial knees. Students will develop techniques for unit testing their applications during the development cycle so scalability problems can be eliminated before the application goes into beta/pilot stages.
- Understanding the MTS/COM+ Interception Based Programming Model
- Designing MTS(Microsoft Transaction Server)/COM+ applications correctly.
- Understanding why application design needs to be from a Session based perspective rather than more traditional Entity based perspective.
- One Object per Client - understand exactly how Single Threaded Apartments work in MTS/COM+
- ASP(Active Server Page) Applications and its use of the One Object per Client model
- What are the features of MTS/COM+?
- Thread Pooling
- Hiding the hideous details of DCOM (Distributed Component Object Model)
- Database Connection Pooling
- Declarative Transactions
- How have people written MTS/COM+ applications in the past? What have we all learned and will this class help students to avoid these mistakes in the future?
- Configured Components
- Understanding the Object Context
- What is a Context Wrapper and is it always helping me
- Understanding Activities and how are they created?
- Creating packages and how to correctly configure components within them.
- Critical Information: When and when not to use Server Packages and Library Packages.
- Understanding exactly what occurs behind the scenes creating instances of classes within MTS and COM+
- What is the SCM(Service Control Manager) and how does it work with MTS? What about COM+?
- Critical Information: Using ObjectContext.CreateInstance(), CreateObject() and the New keyword correctly.
- Using the Shared Property Manager(SPM)
- Raw-Configured and Non-Configured Components
- Why shouldn't components always be configured?
- Performance benefits of Raw-configured and non-configured components.
- How much faster are these types of component than Configured components and why?
- Using Object Construction and the Construct String
- What can Configured components do that Raw-configured components can't?
- How do I handle transactions?
- Performance testing your components from a Win32 front end
- Demystifying Transactions
- Local Transactions vs. Declarative Transactions
- When are Local transactions appropriate?
- When should Declarative Transactions be implemented?
- Two Options for Local Transactions
- Handling Transactions with Stored Procedures
- Using Transact-SQL to manage transactions in SQL Server 2000
- Why do some people say this is bad and why are they full of hot air?
- Handling Transactions with ADO 2.x(Active Data Objects)
- Using the Connection Object to create your local transactions
- Why this method works so well when you're not sure what the database is that will be used.
- Understanding Isolation Levels
- Repeatable Read
- Efficient Data Access in Ditributed Applications
- The goal is to decrease round trips to and from the database
- Revisiting why traditional, strict, hierarchical object models generate excess network traffic
- Designing from the Session based perspective
- Executing Stored Procedures as a Batch to reduce network traffic
- Understanding Database connection pooling
- Writing Efficient Active Server Pages Applications
- Understanding the Context for an Active Server Page
- Writing DLL's for use within a scripting environment
- Avoiding the overhead of additional contexts for instances of components
- Using the Transaction directive in an ASP - Pros and Cons
- What happens if I assign a session variable to a VB component? DON'T do this!
- Strategies for correctly handling session state
- Using the Windows Application Stress tool to gauge the performance of Active Server Page Applications and server side components
- Implementing Role Based Security and Using the MTS/COM+ Admin Objects
- Determining the clients role with the ObjectContext
- Using the Security object to determine the client's role
- Using roles to prevent access to an individual method of a component
- Using the MTS or COM+ Admin objects to programmatically work with packages, components, interfaces and roles
- Using the MTS Admin Objects to install components and create and export packages
- Role of XML in Windows DNA Applications
- Can the use of XML defend applications against a constantly changing data access technology (ADO)?
- Using the DOM(Document Object Model) and/or SAX(Simple API for XML) parsing mechanisms for manipulating XML on the Server Side
- Using XSLT(Extensible Stylesheet Language for Transformations) for presentation purposes on the Server Side
- Designing VB 6.0 Applications for migration to VB.NET
- Understanding the changes in VB.NET so we can try to make migration easier in the future
- Which data types and keywords should be avoided?
- Where should I declare my variables?