Performance Testing Microsoft .NET Web Applications

Microsoft ACE Team

  • 出版商: Microsoft Press
  • 出版日期: 2002-09-24
  • 售價: $1,515
  • 貴賓價: 9.5$1,439
  • 語言: 英文
  • 頁數: 284
  • 裝訂: Hardcover
  • ISBN: 0735615381
  • ISBN-13: 9780735615380
  • 相關分類: .NET






Find out how to test your Web applications for world-class performance and scalability.

The shift from stand-alone desktop applications to Web-enabled applications that accommodate hundreds of thousands of simultaneous users makes performance testing critical. Find out how to make your Microsoft® .NET-based applications perform as well as or better than traditional desktop applications with this book—written by the Microsoft team that tests and tunes hundreds of Web sites and Web-based applications. You’ll learn how to take advantage of the best available tools to plan and execute performance tests, configure profile tools, analyze performance data from Microsoft Internet Information Services, Microsoft ASP.NET, managed code, the SQL tier, and more. You’ll also learn how to use the testing methodology that Microsoft uses to stress test its own sites—some of the most popular, high-performance Web sites in the world. Topics covered include:

• The testing methodology used on, Xbox™.com, and other high-volume sites
• Planning the performance test
• Stress testing with Microsoft Application Center Test (ACT)
• Monitoring application performance with Performance Monitor
• Testing Web site security
• Application Network Analysis
• Analyzing the Web tier
• Analyzing managed code
• Analyzing the SQL tier
• Transaction Cost Analysis (TCA)

• A fully searchable electronic copy of the book
• Scripts that test the performance of


Table of Contents:

Acknowledgements xiii
    Introduction xv
1  Laying the Performance Analysis Groundwork 1
    Why Is Performance Testing and Tuning Important? 1
    Effects of Current and Emerging Architecture Technologies 3
    What Is .NET? 4
        The .NET Platform 4
        Standard .NET Protocols 6
        Web Service Description Language (WSDL) 7
        Universal Description, Discovery, and Integration (UDDI) 7
        What Is an XML Web Service? 7
        Devices Drive Demand for Web Services 8
        Web Services Will Increase Importance of Web Performance Testing 9
    Performance Goals 9
        Computer Interaction Behavioral Patterns 10
    Performance Testing Your Application 11
        Planning Performance Analysis 12
        Creating Effective Stress Scripts 13
        Executing Stress Tests 13
        Analyzing Performance Results 13
    Conclusion 15
2  Preparing and Planning for the Performance Test 17
    Identifying Performance Goals 18
        Response Time Acceptability Goals and Targets 18
        Throughput Goals and Concurrent User Targets 19
        Performance Growth Analysis 20
    User Activity Profile 22
    Backend Activity Profile 23
        Identifying a Web Application's User Activity 23
        Identifying a Web Application's Backend Performance Bottlenecks 24
    Key Performance Metrics Criteria 24
    Mirroring the Production Environment 26
    Putting It Together in a Performance Test Plan 27
    Conclusion 28
3  Stress Testing with Microsoft Application Center Test (ACT) 29
    Getting Started 29
        What is ACT? 30
        Installing Microsoft ACT 30
    Core Concepts of ACT 32
        Dynamic Tests 32
        Concurrent Users and ACT Simultaneous Browser Connections 33
        Users and Groups 34
        Cookies 35
        Headers 35
        Authentication and Encryption 36
        Secure Sockets Layer (SSL) 38
        Using SOAP with ACT 38
        Parsing Viewstate within ACT 39
        Protecting your Web Site from Inadvertent Stress Testing 40
    Running ACT 40
        Overview of the ACT User Interface 41
        Creating a Test Script 44
        Executing a Performance/Stress Test 60
    Conclusion 62
4  Monitoring Application Performance with System Monitor 63
    Using System Monitor 63
        Viewing Real-Time Performance Data 65
        How Often Should You Collect Data? 69
        Logging and Viewing Logged Data 70
        Monitoring Remote Computers 76
    Monitoring Objects, Counters, and Instances for Performance Bottlenecks 77
        Processor Bottlenecks 77
    Typical Processor-related Problems and Solutions 79
        System Object 80
        Disk Bottlenecks 82
        How the ACE Team Discovered a Disk Bottleneck 83
        Disk Architecture Matters to Performance 85
        Memory 86
        How the ACE Team Discovered a Memory Leak 87
        Create and Configure Alerts 89
    Conclusion 94
5  Application Network Analysis 95
    Conducting an Application Network Analysis 95
        Network Latency 96
        Network Round Trips 98
        Reducing Network Round Trips 98
        Data Transferred 99
        Reducing the Quantity of Data Transferred 100
        Processing Delay 102
        Reducing Processing Delays 103
        Response Times 104
        User Scenarios 105
    Using Microsoft Network Monitor 106
        Capturing Network Traffic 112
        Using Compuware's Application Expert 115
        Interpreting Network Captures with Application Expert 119
    Conclusion 124
6  Analyzing and Performance Tuning the Web Tier 125
    Getting Started 125
    Understanding Configuration and Performance 126
        ASP.NET File Extensions 126
        Authentication in ASP.NET 127
        Configuration Files 128
        Understanding Your Web Application 130
    Profiling a .NET Web Application 130
        IIS Log Files 131
        Tracing Problems to the Code Level 137
        System Monitor Counters 142
    Performance Tuning Tips 145
        Application and Session State 145
        Caching in ASP.NET 146
        Disabling ViewState 149
        ADO.NET Tips 149
    Common Web Tier Bottlenecks 155
    Scaling the Web Tier 158
        Scale Out, Scale Up, or Performance Tune? 158
        When to Scale your Web Tier? 159
        How to Scale Out your Web Tier? 160
    Conclusion 161
7  Performance Analysis of Managed Code 163
    CLR and Performance 163
        Microsoft Intermediate Language 164
        The Just-in-Time Compiler 164
        The Pre-JIT Alternative 165
    The Life and Times of a .NET Web Application 166
        Load Time—AppDomains 166
        Run Time—Interoperability 166
        Run Time—Garbage Collection 167
        Run Time—Exceptions 171
        .NET Performance Counters 172
        .NET CLR Memory Object 173
        .NET CLR Loading 175
        .NET CLR LocksAndThreads 176
        .NET CLR Exceptions 177
        .NET CLR Security 178
    Profiling Managed Code 179
        Using Compuware DevPartner Studio 179
        Using AppMetrics to Monitor .NET Enterprise Services Components 184
        Pre-Production Monitoring in AppMetrics 185
        Production Monitoring 187
    Conclusion 190
8  Analyzing the SQL Tier 191
    Getting Started 192
    Identifying Bottlenecks 192
        Tools We Use 193
        Blocking Problems 200
    Index Tuning 207
        Analyzing the Execution Plan 207
        Understanding Indexes 214
        Choosing Right Indexes 215
    Conclusion 229
9  Estimating IIS Tier Capacity with Transaction Cost Analysis 231
    Concurrent Users: A Loosely Defined Term 232
        Concurrent Server Request Processing 233
        TCA Concurrent Users 233
    Benefits of Completing a TCA 234
    TCA In Five Steps 235
        Step 1—Create A User Profile 237
        Step 2—Stress Test for User Operation Costs 238
        Step 3—Calculate the Cost per User Operation 241
        Step 4—Estimate Site Capacity 245
        Step 5—Verify Site Capacity 247
    Conclusion 249
10  Performance Modeling: Tools for Predicting Performance 251
    Predicting and Evaluating Performance Through TCA 252
    Advanced Performance Modeling 252
    Performance Modeling Technology 253
        Modeling Scenarios 253
        Performance Modeling Methods 255
        Performance Modeling Tools 258
    Indy: A Performance Technology Infrastructure 258
        Indy Concepts 258
        Indy Architecture 259
        IndyView 261
        TCA vs. Performance Modeling Conclusions 271
        Building What-if Scenarios Using Indy 272
    Conclusion 273