Chapter5-ImprovingManagedCodePerformance.pdf资源-CSDN文库

需积分: 1 90 浏览量 2017-10-27 15:15:15 上传评论收藏 525KB PDF 举报

在.NET平台上，托管代码性能优化是一个重要课题，微软官方文档提供了一系列的设计和编程技巧来帮助开发者提升其.NET应用程序的性能。本章的目的是提供一系列优化和改进托管代码性能的技术，指导开发者编写可以充分利用公共语言运行时（Common Language Runtime，简称CLR）高性能特性的托管代码。关键内容涵盖了以下几个方面： 1. **类设计考虑**：在.NET架构中，合理设计类结构是性能优化的首要步骤。设计时应考虑如何通过继承、封装和多态性等面向对象的原则来简化代码逻辑，提高代码复用性和可维护性。 2. **实现考虑**：实现阶段需要考虑代码的可读性、可测试性和错误处理。在设计模式的选择上，例如工厂模式、单例模式、策略模式等，需要结合具体业务场景合理运用。 3. **垃圾回收（Garbage Collection，简称GC）详解**：CLR提供的垃圾回收机制管理内存的分配和回收，可以减少内存泄漏和碎片化问题，但不当的使用也可能导致性能瓶颈。文档中提供了有关垃圾回收的深入讲解以及如何编写代码以减少垃圾回收的影响。 4. **终结器和Dispose模式**：在.NET中，终结器（Finalize）和Dispose模式用于资源释放。了解它们的工作原理和最佳实践对于编写资源安全的代码至关重要。 5. **内存固定（Pinning）**：固定内存可以防止垃圾回收器移动托管对象，这在与非托管代码交互时尤其重要。文档提供了何时以及如何正确地进行内存固定的指南。 6. **多线程编程详解**：多线程能够提升应用程序的性能和响应能力，但是不当的同步可能会导致死锁、竞态条件等问题。文档深入讲解了多线程编程的概念，并给出了一些指导原则。 7. **异步调用详解**：异步编程可以提升应用程序的性能和用户体验，特别是在I/O密集型操作中。文档探讨了如何有效使用异步编程模式，包括异步编程模型***。 8. **锁和同步详解**：在多线程环境中，正确的锁和同步机制对于避免竞争条件和确保线程安全至关重要。文档详细讲解了锁机制的设计和使用。 9. **值类型和引用类型**：理解.NET中的值类型和引用类型之间的差异对于编写高效的代码非常重要。文档阐释了值类型和引用类型之间的转换和性能影响。 10. **装箱和取消装箱详解**：装箱（Boxing）和取消装箱（Unboxing）是.NET将值类型和引用类型数据相互转换的过程，不恰当的使用会导致性能问题。文档提供了关于装箱和取消装箱的详细说明及最佳实践。 11. **异常管理**：异常处理是.NET编程中重要的部分，但是不恰当的异常处理方式会严重影响性能。文档中讨论了如何合理地使用异常处理来保持代码的性能。 12. **迭代和循环**：循环是程序中不可或缺的部分，但也是性能瓶颈的常见来源。文档提供了迭代和循环的优化技巧。 13. **字符串操作**：字符串在.NET中是不可变的，因此不当的字符串处理会带来性能问题。文档详细介绍了字符串操作的最佳实践。 14. **数组和集合**：数组和集合在.NET中是最基本的数据结构，文档针对如何选择和使用数组和集合提供了技巧和建议。 15. **使用Ngen.exe预编译代码**：Ngen.exe是一个.NET工具，可以将.NET中间语言（Intermediate Language，简称IL）代码转换为本机代码。预编译可以加快启动时间，提升性能。文档讲述了如何使用Ngen.exe进行代码的预编译。在应用这些技巧和最佳实践时，开发者应该理解它们的应用场景，权衡不同技术的利弊，以达到最佳的性能优化效果。由于文档已标记为过时内容，因此在实际操作中，开发者还应该查阅最新的官方文档和社区资源以获取最新的性能优化信息。

资源推荐

资源详情

资源评论

2017/10/27 Chapter5ImprovingManagedCodePerformance
https://msdn.microsoft.com/enus/library/ff647790(d=printer).aspx 1/50
Chapter 5 — Improving Managed Code
Performance

Retired Content
This content is outdated and is no longer being maintained. It is provided as a courtesy for individuals who are still using these
technologies. This page may contain URLs that were valid when originally published, but now link to sites or pages that no longer exist.
Improving .NET Application Performance and Scalability
J.D. Meier, Srinath Vasireddy, Ashish Babbar, Rico Mariani, and Alex Mackman 
Microsoft Corporation
May 2004
Related Links
Home Page for Improving .NET Application Performance and Scalability
Chapter 4 — Architecture and Design Review of a .NET Application for Performance and Scalability
Send feedback to Scale@microsoft.com
patterns & practices Library
Summary: This chapter provides design and coding techniques for optimizing and improving the performance of your managed code.
This chapter will help you develop managed code that takes full advantage of the high performance offered by the common language
runtime. Key topics covered in this chapter include class design considerations, memory management and garbage collection issues,
when and how to pin memory, developing efficient multithreaded code, using effective asynchronous execution, boxing considerations,
string manipulation, exception management, arrays, collections, precompiling code with Ngen.exe, and much more.
Contents
Objectives 
Overview 
How to Use This Chapter 
Architecture 
Performance and Scalability Issues 
Design Considerations 
Class Design Considerations 
Implementation Considerations 
Garbage Collection Explained 
Garbage Collection Guidelines 
Finalize and Dispose Explained
Dispose Pattern 
Finalize and Dispose Guidelines 
Pinning 
Threading Explained 
Threading Guidelines 
Asynchronous Calls Explained 
Asynchronous Guidelines 
Locking and Synchronization Explained 

2017/10/27 Chapter5ImprovingManagedCodePerformance
https://msdn.microsoft.com/enus/library/ff647790(d=printer).aspx 2/50
Locking and Synchronization Guidelines 
Value Types and Reference Types 
Boxing and Unboxing Explained 
Boxing and Unboxing Guidelines 
Exception Management 
Iterating and Looping 
String Operations 
Arrays 
Collections Explained 
Collection Guidelines 
Collection Types 
Reflection and Late Binding 
Code Access Security 
Working Set Considerations 
Ngen.exe Explained 
Ngen.exe Guidelines 
Summary 
Additional Resources
Objectives
Optimize assembly and class design.
Maximize garbage collection ﴾GC﴿ efficiency in your application.
Use Finalize and Dispose properly.
Minimize boxing overhead.
Evaluate the use of reflection and late binding.
Optimize your exception handling code.
Make efficient use of iterating and looping constructs.
Optimize string concatenation.
Evaluate and choose the most appropriate collection type.
Avoid common threading mistakes.
Make asynchronous calls effectively and efficiently.
Develop efficient locking and synchronization strategies.
Reduce your application's working set.
Apply performance considerations to code access security.
Overview
Considerable effort went into making the common language runtime ﴾CLR﴿ suitable for applications that require high performance.
However, the way you write managed code can either take advantage of that capability or it can hinder it. This chapter identifies the core
performance‐related issues that you need to be aware of to develop optimized managed code. It identifies common mistakes and many
ways to improve the performance of your managed code.
The chapter starts by presenting the CLR architecture and provides an overview of the top performance and scalability issues to be aware
of when you develop managed code. It then presents a set of design guidelines you should apply to all of your managed code
development ﴾such as business logic, data access logic, utility component, or Web page assembly﴿. The chapter then presents a series of
sections that highlight the top recommendations for each of the performance critical areas of managed code development. These include
memory management and garbage collection, boxing operations, reflection and late binding, use of collections, string handling,
threading, concurrency, asynchronous operations, exception management, and more.
How to Use This Chapter
This chapter presents the CLR architecture, top performance and scalability issues, and a set of design guidelines for managed code
development. To get the most from this chapter, do the following:
Jump to topics or read from beginning to end. The main headings in this chapter help you locate the topics that interest you.
Alternatively, you can read the chapter from beginning to end to gain a thorough appreciation of performance and scalability
design issues.
Know the CLR architecture and components. Understanding managed code execution can help towards writing code optimized
for performance.
Know the major performance and scalability issues. Read "Performance and Scalability Issues" in this chapter to learn about the
major issues that can impact the performance and scalability of managed code. It is important to understand these key issues so
you can effectively identify performance and scalability problems and apply the recommendations presented in this chapter.

2017/10/27 Chapter5ImprovingManagedCodePerformance

https://msdn.microsoft.com/enus/library/ff647790(d=printer).aspx 3/50

Measure your application performance. Read the "CLR and Managed Code" and ".NET Framework Technologies" sections of

Chapter 15, "Measuring .NET Application Performance"to learn about the key metrics that can be used to measure application

performance. It is important that you be able to measure application performance so that performance issues can be accurately

targeted.

Test your application performance. Read Chapter 16, "Testing .NET Application Performance" to learn how to apply performance

testing to your application. It is important that you apply a coherent testing process and that you be able to analyze the results.

Tune your application performance. Read the "CLR Tuning" section of Chapter 17, "Tuning .NET Application Performance" to

learn how to resolve performance issues identified through the use of tuning metrics.

Use the accompanying checklist in the "Checklists" section of this guide. Use the "Checklist: Managed Code Performance"

checklist to quickly view and evaluate the guidelines presented in this chapter.

Architecture

The CLR consists of a number of components that are responsible for managed code execution. These components are referred to

throughout this chapter, so you should be aware of their purpose. Figure 5.1 shows the basic CLR architecture and components.

Figure 5.1: CLR architecture

The way you write managed code significantly impacts the efficiency of the CLR components shown in Figure 5.1. By following the

guidelines and techniques presented in this chapter, you can optimize your code, and enable the run‐time components to work most

efficiently. The purpose of each component is summarized below:

JIT compiler. The just‐in‐time ﴾JIT﴿ compiler converts the Microsoft intermediate language ﴾MSIL﴿ that is contained in an assembly

into native machine code at run time. Methods that are never called are not JIT‐compiled.

Garbage collector. The garbage collector is responsible for allocating, freeing, and compacting memory.

Structured exception handling. The runtime supports structured exception handling to allow you to build robust, maintainable

code. Use language constructs such as try/catch/finally to take advantage of structured exception handling.

Threading. The .NET Framework provides a number of threading and synchronization primitives to allow you to build high

performance, multithreaded code. Your choice of threading approach and synchronization mechanism impacts application

concurrency; hence, it also impacts scalability and overall performance.

Security. The .NET Framework provides code access security to ensure that code has the necessary permissions to perform specific

types of operations such as accessing the file system, calling unmanaged code, accessing network resources, and accessing the

registry.

Loader. The .NET Framework loader is responsible for locating and loading assemblies.

Metadata. Assemblies are self‐describing. An assembly contains metadata that describes aspects of your program, such as the set

of types that it exposes, and the members those types contain. Metadata facilitates JIT compilation and is also used to convey

version and security‐related information.

Interop. The CLR can interoperate with various kinds of unmanaged code, such as Microsoft Visual Basic®, Microsoft Visual

C++®, DLLs, or COM components. Interop allows your managed code to call these unmanaged components.

Remoting. The .NET remoting infrastructure supports calls across application domains, between processes, and over various

network transports.

2017/10/27 Chapter5ImprovingManagedCodePerformance

https://msdn.microsoft.com/enus/library/ff647790(d=printer).aspx 4/50

Debugging. The CLR exposes debugging hooks that can be used to debug or profile your assemblies.

Performance and Scalability Issues

This section is designed to give you a high‐level overview of the major issues that can impact the performance and scalability of managed

code. Subsequent sections in this chapter provide strategies, solutions, and technical recommendations to prevent or resolve these issues.

There are several main issues that impact managed code performance and scalability:

Memory misuse. If you create too many objects, fail to properly release resources, preallocate memory, or explicitly force garbage

collection, you can prevent the CLR from efficiently managing memory. This can lead to increased working set size and reduced

performance.

Resource cleanup. Implementing finalizers when they are not needed, failing to suppress finalization in the Dispose method, or

failing to release unmanaged resources can lead to unnecessary delays in reclaiming resources and can potentially create resource

leaks.

Improper use of threads. Creating threads on a per‐request basis and not sharing threads using thread pools can cause

performance and scalability bottlenecks for server applications. The .NET Framework provides a self‐tuning thread pool that should

be used by server‐side applications.

Abusing shared resources. Creating resources per request can lead to resource pressure, and failing to properly release shared

resources can cause delays in reclaiming them. This quickly leads to scalability issues.

Type conversions. Implicit type conversions and mixing value and reference types leads to excessive boxing and unboxing

operations. This impacts performance.

Misuse of collections. The .NET Framework class library provides an extensive set of collection types. Each collection type is

designed to be used with specific storage and access requirements. Choosing the wrong type of collection for specific situations

can impact performance.

Inefficient loops. Even the slightest coding inefficiency is magnified when that code is located inside a loop. Loops that access an

object's properties are a common culprit of performance bottlenecks, particularly if the object is remote or the property getter

performs significant work.

Design Considerations

The largest contributing factor to application performance is the application architecture and design. Make sure performance is a

functional requirement that your design and test performance takes into account throughout the application development life cycle.

Application development should be an iterative process. Performance testing and measuring should be performed between iterations and

should not be left to deployment time.

This section summarizes the major design considerations to consider when you design managed code solutions:

Design for efficient resource management.

Reduce boundary crossings.

Prefer single large assemblies rather than multiple smaller assemblies.

Factor code by logical layers.

Treat threads as a shared resource.

Design for efficient exception management.

Design for Efficient Resource Management

Avoid allocating objects and the resources they encapsulate before you need them, and make sure you release them as soon as your

code is completely finished with them. This advice applies to all resource types including database connections, data readers, files,

streams, network connections, and COM objects. Use finally blocks or Microsoft Visual C#® using statements to ensure that resources

are closed or released in a timely fashion, even in the event of an exception. Note that the C# using statement is used only for resources

that implement IDisposable; whereas finally blocks can be used for any type of cleanup operations.

Reduce Boundary Crossings

Aim to reduce the number of method calls that cross remoting boundaries because this introduces marshaling and potentially thread

switching overhead. With managed code, there are several boundaries to consider:

Cross application domain. This is the most efficient boundary to cross because it is within the context of a single process. Because

the cost of the actual call is so low, the overhead is almost completely determined by the number, type, and size of parameters

passed on the method call.

Cross process. Crossing a process boundary significantly impacts performance. You should do so only when absolutely necessary.

For example, you might determine that an Enterprise Services server application is required for security and fault tolerance reasons.

Be aware of the relative performance tradeoff.

Cross machine. Crossing a machine boundary is the most expensive boundary to cross, due to network latency and marshaling

overhead. While marshaling overhead impacts all boundary crossings, its impact can be greater when crossing machine

2017/10/27 Chapter5ImprovingManagedCodePerformance

https://msdn.microsoft.com/enus/library/ff647790(d=printer).aspx 5/50

boundaries. For example, the introduction of an HTTP proxy might force you to use SOAP envelopes, which introduces additional

overhead. Before introducing a remote server into your design, you need to consider the relative tradeoffs including performance,

security, and administration.

Unmanaged code. You also need to consider calls to unmanaged code, which introduces marshaling and potentially thread

switching overhead. The Platform Invoke ﴾P/Invoke﴿ and COM interop layers of the CLR are very efficient, but performance can vary

considerably depending on the type and size of data that needs to be marshaled between the managed and unmanaged code. For

more information, see Chapter 7, "Improving Interop Performance."

Prefer Single Large Assemblies Rather Than Multiple Smaller Assemblies

To help reduce your application's working set, you should prefer single larger assemblies rather than multiple smaller assemblies. If you

have several assemblies that are always loaded together, you should combine them and create a single assembly.

The overhead associated with having multiple smaller assemblies can be attributed to the following:

The cost of loading metadata for smaller assemblies.

Touching various memory pages in pre‐compiled images in the CLR in order to load the assembly ﴾if it is precompiled with

Ngen.exe﴿.

JIT compile time.

Security checks.

Because you pay for only the memory pages your program accesses, larger assemblies provide the Native Image Generator utility

﴾Ngen.exe﴿ with a greater chance to optimize the native image it produces. Better layout of the image means that necessary data can be

laid out more densely, which in turn means fewer overall pages are needed to do the job compared to the same code laid out in multiple

assemblies.

Sometimes you cannot avoid splitting assemblies; for example, for versioning and deployment reasons. If you need to ship types

separately, you may need separate assemblies.

Factor Code by Logical Layers

Consider your internal class design and how you factor code into separate methods. When code is well factored, it becomes easier to

tune to improve performance, maintain, and add new functionality. However, there needs to be a balance. While clearly factored code can

improve maintainability, you should be wary of over abstraction and creating too many layers. Simple designs can be effective and

efficient.

Treat Threads as a Shared Resource

Do not create threads on a per‐request basis because this can severely impact scalability. Creating new threads is also a fairly expensive

operation that should be minimized. Treat threads as a shared resource and use the optimized .NET thread pool.

Design for Efficient Exception Management

The performance cost of throwing an exception is significant. Although structured exception handling is the recommended way of

handling error conditions, make sure you use exceptions only in exceptional circumstances when error conditions occur. Do not use

exceptions for regular control flow.

Class Design Considerations

Class design choices can affect system performance and scalability. However, analyze your tradeoffs, such as functionality, maintainability,

and company coding guidelines. Balance these with performance guidelines.

This section summarizes guidelines for designing your managed classes:

Do not make classes thread safe by default.

Consider using the sealed keyword.

Consider the tradeoffs of virtual members.

Consider using overloaded methods.

Consider overriding the Equals method for value types.

Know the cost of accessing a property.

Consider private vs. public member variables.

Limit the use of volatile fields.

Do Not Make Classes Thread Safe by Default

Consider carefully whether you need to make an individual class thread safe. Thread safety and synchronization is often required at a

higher layer in the software architecture and not at an individual class level. When you design a specific class, you often do not know the

剩余49页未读，继续阅读

评论收藏

内容反馈

seainchina

粉丝: 0
资源: 2

Chapter 5 - Improving Managed Code Performance.pdf

最新资源

Chapter 5 - Improving Managed Code Performance.pdf

藏经阁-Improving Python and Spark.pdf

PlanViz - Improving SAP HANA Performance.zip

Signal Integrity - Simplified(Eric Bogatin).pdf

藏经阁-Improving Resource Efficiency.pdf

Study Tips for Improving Long-Term Retention and Recall.pdf

Baier, Katoen - 2008 - Principles of Model Checking.pdf

藏经阁-Improving Python and Spark Per.pdf

High Performance in-memory computing with Apache Ignite.pdf

AngularJS - Novice to Ninja.pdf.pdf )

Refactoring-Improving+the+Design+of+Existing+Code.pdf

refactoring-improving the design of existing code.pdf

Simulation-based Training of AI.pdf

2008-Improving Maximum Margin Matrix Factorization.pdf

Refactoring-Improving the Design of Existing Code.pdf

Cloud and Fog Computing in 5G Mobile Networks-IET(2017).pdf

Sea-SE.US-东南亚互联网旗舰启航.pdf

ILSpy 安装包和压缩包

U8点击按钮打开生成凭证界面

DevExpress22.X完美Patch资源

基于C#与Sql Server的智慧星学生选课管理系统.rar

Microsoft Edge 127.0.2651.98 便携版

CefFlashBrowser - Flash浏览器

Camtasia 2024v24.0.0.1046

HslCommunication.dll 7.0.1 免费版本 全部源代码和测试工程

关于西门子PLC与上位机通讯的damo程序，以及更改后的S7.net+

Aspose.PDF for .NET v24.3.0 (13 Mar 2024) + License Key

最新资源

HslCommunication.dll 7.0.1 免费版本全部源代码和测试工程