优化NET代码：高性能编程指南(第2版)

4星 · 超过85%的资源需积分: 12 58 浏览量更新于2024-07-17 1 收藏 11.76MB PDF 举报

"高清彩版 Writing High-Performance .NET Code(2nd)——专注于提升.NET代码性能的指南" 这本书，《Writing High-Performance .NET Code》第二版，深入探讨了如何编写高性能的.NET应用程序。作者通过丰富的经验和实践，揭示了在.NET平台上优化代码的关键策略和技巧。本书适用于希望最大化应用性能的.NET开发者，无论他们是在桌面、服务器还是移动环境工作。书中的内容分为多个部分，涵盖了内存管理、JIT编译、异步编程等多个关键领域。作者首先介绍了选择.NET的原因，包括其与原生代码的性能对比，以及管理代码所带来的优势和成本。强调了与公共语言运行时（CLR）合作而非对抗的重要性，以及优化的层次结构，提醒读者避免过于简单的优化陷阱。在内存管理部分，书中详细讲解了内存分配和垃圾收集的工作原理，以及各种配置选项对性能的影响。作者给出了许多实用的性能提示，并教导读者如何调查内存和GC行为，帮助开发者更好地理解和解决内存问题。 JIT（Just-In-Time）编译是.NET性能的关键组成部分。书中详细阐述了JIT的优势，展示了JIT的实际操作过程，以及它如何进行优化。此外，还讨论了如何减少JIT和启动时间，利用多核JIT优化，并介绍了预编译工具NGEN和.NET Native的作用。同时，书里还提到了如何通过定制预热来提高JIT性能，并指出了JIT无法比拟的情况及检查JIT行为的方法。在异步编程章节，作者讲解了.NET中的线程池和任务并行库（TPL），这些工具在处理大量并发操作时能显著提高效率。书中还涉及到了异步编程的最佳实践，帮助开发者理解如何有效利用异步机制来提升程序的响应性和可伸缩性。除此之外，书中还涵盖了其他性能测量和工具的选择，如基准测试、性能计数器等，以及如何考虑测量数据的平均值与百分位数。所有这些内容旨在帮助开发者建立一套完整的性能优化方法论，从而编写出更高效、更稳定的.NET代码。《Writing High-Performance .NET Code》第二版是一本全面而深入的指南，它不仅解释了.NET性能优化的理论基础，还提供了大量实践建议和案例，是.NET开发者不可或缺的参考资料。通过阅读和应用书中的知识，开发者可以充分利用.NET平台的潜力，创造出性能卓越的应用程序。

stackalloc, finalization, weak references, finding memory leaks, and

much more.

Expanded discussion of different code warmup techniques.

More information about TPL and a new section about TPL Dataflow.

Discussion of ref-returns and locals.

Significantly expanded discussion of collections, including initial

capacity, sorting, and key comparisons.

Detailed analysis of LINQ costs.

Examples of SIMD algorithms.

How to build automatic code analyzers and fixers.

An appendix with high-level tips for ADO.NET, ASP.NET, and WPF.

…and much more!

I am confident that, even if you read the first edition, this second edition is

more than worth your time and attention.

Introduction

Purpose of this Book

.NET is an amazing system for building software. It allows us to build

functional, connected apps in a fraction of the time it would have taken us

years ago. So much of it just works, and that is a great thing. It offers

applications memory and type safety, a robust framework library, services

like automatic memory management, and so much more.

Programs written with .NET are called managed applications because they

depend on a runtime and framework that manages many of their vital tasks

and ensures a basic safe operating environment. Unlike unmanaged, or

native, software written directly to the operating system’s APIs, managed

applications do not have free reign of their processes.

This layer of management between your program and the computer’s

processor can be a source of anxiety for developers who assume that it must

add some significant overhead. This book will set you at ease, demonstrate

that the overhead is worth it, and that the supposed performance degradation

is almost always exaggerated. Often, the performance problems developers

blame on .NET are actually due to poor coding patterns and a lack of

knowledge of how to optimize their programs on this framework. Skills

gained from years of optimizing software written in C++, Java, or Python

may not always apply to .NET managed code, and some advice is actually

detrimental. Sometimes the rapid development enabled by .NET can

encourage people to build bloated, slow, poorly optimized code faster than

ever before. Certainly, there are other reasons why code can be of poor

quality: lack of skill generally, time pressure, poor design, lack of developer

resources, laziness, and so on. This book will explicitly remove lack of

knowledge about the framework as an excuse and attempt to deal with some

of the others as well. With the principles explained in this book, you will

learn how to build lean, fast, efficient applications that avoid these missteps.

In all types of code, in all platforms, the same thing is true: if you want

performant code, you have to work for it.

Performance work should never be left for the end, especially in a macro or

architectural sense. The larger and more complex your application, the earlier

you need to start considering performance as a major feature.

I often give the example of building a hut versus building a skyscraper. If you

are building a hut, it does not really matter at what point you want to

optimize some feature: Want windows? Just cut a hole in the wall. Want to

add electricity? Bolt it on. You have a lot of freedom about when to

completely change how things work because it is simple, with few

dependencies.

A skyscraper is different. You cannot decide you want to switch to steel

beams after you have built the first five floors out of wood. You must

understand the requirements up front as well as the characteristics of your

building materials before you start putting them together into something

larger.

This book is largely about giving you an idea of the costs and benefits of your

building materials, from which you can apply lessons to whatever kind of

project you are building.

This is not a language reference or tutorial. It is not even a detailed discussion

of the CLR. For those topics, there are other resources. (See the end of the

book for a list of useful books, blogs, and people to pay attention to.) To get

the most out of this book you should already have in-depth experience with

.NET.

There are many code samples, especially of underlying implementation

details in IL or assembly code. I caution you not to gloss over these sections.

You should try to replicate my results as you work through this book so that

you understand exactly what is going on.

This book will teach you how to get maximum performance out of managed

code, while sacrificing none or as few of the benefits of .NET as possible.

You will learn good coding techniques, specific things to avoid, and perhaps

most importantly, how to use freely available tools to easily measure your

performance. This book will teach you those things with minimum fluff. This

book is what you need to know, relevant and concise, with no padding of the

content. Most chapters begin with general knowledge and background,

followed by specific tips in a cook-book approach, and finally end with a

section on step-by-step measurement and debugging for many different

scenarios.

Along the way you will deep-dive into specific portions of .NET, particularly

the underlying Common Language Runtime (CLR) and how it manages your

memory, generates your code, handles concurrency, and more. You will see

how .NET’s architecture both constrains and enables your software, and how

your programming choices can drastically affect the overall performance of

your application. As a bonus, I will share relevant anecdotes from the last

nine years of building very large, complex, high-performance .NET systems

at Microsoft. You will likely notice that my bias throughout this book is for

server applications, but nearly everything discussed in this book is applicable

to desktop, web, and mobile applications as well. Where appropriate, I will

share advice for those specific platforms.

Understanding the fundamentals will give you the “why” explanations that

will allow the performance tips to make sense. You will gain a sufficient

understanding of .NET and the principles of well-performing code so that

when you run into circumstances not specifically covered in this book, you

can apply your newfound knowledge and solve unanticipated problems.

Programming under .NET is not a completely different experience from all

the programming you have ever done. You will still need your knowledge of

algorithms and most standard programing constructs are pretty much the

same, but we are talking about performance optimizations, and if you are

coming from an unmanaged programming mindset, there are very different

things you need to observe. You may not have to call delete explicitly any

more (hurray!), but if you want to get the absolute best performance, you

better believe you need to understand how the garbage collector is going to

affect your application.

If high availability is your goal, then you are going to need to be concerned

about JIT compilation to some degree. Do you have an extensive type

system? Interface dispatch might be a concern. What about the APIs in the

.NET Framework Class Library itself? Can any of those negatively influence

performance? Are some thread synchronization mechanisms better than

others? Have you considered memory locality when choosing collections or

algorithms?

Beyond pure coding, I will discuss techniques and processes to measure your

performance over time and build a culture of performance in yourself and in

your team. Good performance is not something you do once and then move

on. It needs constant nourishment and care so that it does not degrade over

time. Investing in a good performance infrastructure will pay massive

dividends over time, allowing you to automate most of the grunt work.

The bottom line is that the amount of performance optimization you get out

of your application is directly proportional to the amount of understanding

you have not only of your own code, but also your understanding of the

framework, the operating system, and the hardware you run on. This is true

of any platform you build upon.

All of the code samples in this book are in C#, the underlying IL, or

occasionally x86 or x64 assembly code, but all of the principles here apply to

any .NET language. Throughout this book, I assume that you are using .NET

4.5 or higher, and some examples require newer features only available in

more recent versions. I strongly encourage you to consider moving to the

latest version so that you can take advantage of the latest technologies,

features, bug fixes, and performance improvements.

I do not talk much about specific sub-frameworks of .NET, such as WPF,

WCF, ASP.NET, Windows Forms, Entity Framework, ADO.NET, or

countless others. While each of those frameworks has its own issues and

performance techniques, this book is about the fundamental knowledge and

techniques that you must master to develop code under all scenarios in .NET.

Once you acquire these fundamentals, you can apply this knowledge to every

project you work on, adding domain-specific knowledge as you gain

experience. I did add a small appendix in the back, however, that can give

you some initial guidance if you are trying to optimize ASP.NET, ADO.NET,

or WPF applications.

Overall, I hope to show that performance engineering is just that:

剩余443页未读，继续阅读

weixin_38669689

粉丝: 27
资源: 300

优化NET代码：高性能编程指南(第2版)

Writing High-Performance .NET Code.epub

c3560-ipservicesk9-mz.122-55.SE

Writing High-Performance NET Code(2nd).pdf 2018新版

Writing High-Performance .NET Code(2nd) epub

东华大学在北京2021-2024各专业最低录取分数及位次表.pdf

中国矿业大学(北京)在广东2021-2024各专业最低录取分数及位次表.pdf

NJUST软件课程设计.zip

使用Python语言来模拟一个中秋节日的庆祝活动

1565-基于51单片机的数码管热电偶温度报警（数码管，热电偶，单阀值）proteus、原理图、流程图、物料清单.zip

C++代码注释的版本控制：自动化策略与实

最新资源