What is Writing High-Performance .NET Code about?

Writing High-Performance .NET Code by Ben Watson is a comprehensive guide to optimizing .NET applications for maximum performance. The book provides detailed explanations of CLR functionality, garbage collection optimization, JIT compilation, and multithreading techniques, along with free tool recommendations and step-by-step performance measurement guides. It teaches developers exactly what to do to achieve the best .NET performance through practical examples, profiling tutorials, and lessons from building one of the world's largest high-performance .NET systems.

Who is Ben Watson, author of Writing High-Performance .NET Code?

Ben Watson is a Principal Engineer at Microsoft who has worked on the Bing platform team since 2008. He is recognized as an expert in .NET performance within Microsoft and the broader industry, having designed and built critical components for Bing's query-serving infrastructure. Watson specializes in high-performance server applications and has mentored teams to monitor and improve performance across Microsoft's distributed systems.

Who should read Writing High-Performance .NET Code?

Writing High-Performance .NET Code is essential for .NET developers who want their applications to achieve optimal performance. It's particularly valuable for software engineers working on high-volume, low-latency systems, server applications, or any performance-critical .NET projects. The book suits both intermediate developers seeking to understand CLR internals and experienced programmers who need advanced optimization techniques and profiling strategies.

Is Writing High-Performance .NET Code worth reading?

Writing High-Performance .NET Code is widely regarded as the best-selling and definitive guide for .NET performance optimization. The 2nd edition offers 50% more content than the original, incorporating advances in .NET Core and expanded coverage of modern tools and techniques. With practical insights from building one of the world's largest .NET applications at Microsoft Bing, the book provides actionable guidance rather than just theoretical knowledge, making it highly valuable for developers serious about performance.

What are the main topics covered in Writing High-Performance .NET Code?

Writing High-Performance .NET Code covers garbage collection optimization, JIT compilation analysis, effective multithreading with Task Parallel Library, and performance measurement techniques. Ben Watson explains which .NET features and APIs to use or avoid, code generation strategies, and how to instrument programs with performance counters and ETW events. The book also addresses memory management, profiling with multiple tools, LINQ performance implications, and building performance-minded development teams.

What does Writing High-Performance .NET Code teach about garbage collection?

Writing High-Performance .NET Code provides detailed descriptions of how the .NET garbage collector works and how to optimize code for efficient memory management. Ben Watson explains the generational GC system and recommends aiming for very short-lived or very long-lived memory allocation patterns to maximize efficiency. The book includes guidance on diagnosing GC-related issues using free profilers, analyzing heap memory problems, and understanding new GC configuration options introduced in recent .NET versions.

What's new in the 2nd edition of Writing High-Performance .NET Code?

The 2nd edition of Writing High-Performance .NET Code features a 50% increase in content with new examples, code samples, and diagrams throughout. It covers modern .NET features including ref-returns, value tuples, SIMD support, and Spans, along with expanded Visual Studio usage and more benchmarking techniques. The updated edition addresses .NET Core improvements, code warmup strategies, more detailed LINQ analysis, and tips for high-level frameworks like ASP.NET, ADO.NET, and WPF.

What tools does Writing High-Performance .NET Code recommend for profiling?

Writing High-Performance .NET Code recommends multiple free profiling tools to quickly identify performance bottlenecks in .NET applications. Ben Watson provides tutorials for using Visual Studio's profiling features, performance counters, and ETW (Event Tracing for Windows) for instrumentation. The 2nd edition significantly expands tool coverage, teaching developers how to analyze heap memory, diagnose JIT warmup problems, and use various profilers to measure both application and .NET framework performance.

ハイパフォーマンス .NET 構造化プログラミング ――高速なコードを書くための実践的な手法

ベン・ワトソン

4.33(18 Reviews)

『ハイパフォーマンス .NET 構造化プログラミング ――高速なコードを書くための実践的な手法』の概要

Microsoftのエンジニア、Ben Watsonによる、驚異的な速さの.NETアプリケーションを構築するための必須ガイドを詳しく見ていきましょう。Bingのサーバー・インフラストラクチャの最前線で執筆されたこの技術的傑作は、数千台のマシンで数百万のリクエストを処理するシステムを支える、最適化の秘訣を明らかにしています。

語り方を選ぶ

1冊の本。さまざまな聴き方。

ハイパフォーマンス .NET 構造化プログラミング ――高速なコードを書くための実践的な手法の同じアイデアを、あなたに合う声・深さ・ペースで学べます。いつでも切り替えられます。

第1章

Unleashing the Power of Managed Code

When Ben Watson joined Microsoft's Bing team in 2008, he faced a daunting challenge: build one of the world's highest-performing server applications using .NET-a framework many developers dismissed as too slow for serious performance work. The resulting system now handles millions of low-latency requests across thousands of machines, proving that managed code can indeed deliver exceptional performance. This experience forms the foundation of "Writing High-Performance .NET Code," where Watson dismantles the myth that .NET's management layer inherently creates significant overhead. Instead, he reveals how most performance problems stem from poor coding patterns rather than the framework itself.

第2章

The Surprising Truth About .NET Performance

The conventional wisdom has long suggested that managed code can't compete with native code for raw performance. But is this actually true? Not according to Watson, who argues that what's closer to reality is that .NET makes it easy to write slow code when developers are sloppy and uncritical in their approach. This misconception often leads to premature optimization or wholesale rejection of managed solutions where they might be ideal. When code is compiled to Intermediate Language (IL) and then Just-In-Time (JIT) compiled, the steady-state performance depends primarily on two factors: JIT compiler quality and .NET services overhead. The modern JIT compiler employs sophisticated optimization techniques, including method inlining, loop unrolling, and dead code elimination. Surprisingly, managed code can actually outperform native code in several areas. Memory allocation in .NET can be faster due to its lack of contention compared to native heaps - allocation is essentially a pointer bump in the managed heap. The garbage collector's compaction eliminates fragmentation issues that plague native applications, particularly in long-running processes. JITted code often benefits from better memory locality as the compiler places frequently used code paths together, improving CPU cache utilization. A common objection to managed code is the perceived loss of control, particularly regarding garbage collection timing. However, this view misunderstands how the CLR works. Garbage collection is actually deterministic, following well-defined rules and triggers. Developers can significantly influence its behavior through memory allocation patterns, object scope management, and configuration settings. For instance, using value types for small, frequently-created objects can reduce allocation pressure. Proper implementation of IDisposable ensures timely resource cleanup. The Server GC mode can dramatically improve collection performance on multi-core systems. The key insight is that we should work with the CLR, not against it. Many performance issues arise from fighting the framework rather than understanding and aligning with its expectations. Common anti-patterns include excessive object creation in tight loops, improper use of async/await, and unnecessary boxing operations. The default assumption should always be that the application needs fixing, not the framework, OS, or hardware. Modern .NET applications routinely achieve sub-millisecond response times and can handle millions of operations per second when properly architected. Performance optimization in .NET requires understanding the runtime's behavior. Tools like PerfView, ETW events, and Visual Studio's diagnostic tools provide deep insights into application behavior. The runtime's transparency allows developers to identify and address performance bottlenecks systematically - whether they're related to garbage collection, JIT compilation, or CPU utilization.

聴きながら、すべての言葉を目で追えます

『ハイパフォーマンス .NET 構造化プログラミング ――高速なコードを書くための実践的な手法』の一語一語が音声に合わせてリアルタイムでハイライトされ、自然に読み進められます。

第3章

The Cardinal Rule: Measure, Measure, Measure!

"Measure, Measure, Measure!" is the most important rule in high-performance .NET development. Even experienced developers should resist the urge to skip measurement, as intuition can be dangerously misleading. Watson shares how his team once incorrectly assumed memory usage came from a large dataset when measurement revealed it was actually from assembly loading overhead. Before collecting performance data, you must precisely define what to measure. Using memory as an example, a single concept can have numerous specific metrics (private working set, commit size, heap size, etc.). Goals must be quantifiable and specific, not vague statements like "fast" or "responsive." Good goals include specific circumstances and thresholds, such as "Working set memory usage should never exceed 1GB during peak load of 100 queries per second." When analyzing performance data, consider both averages and percentiles. Percentiles are particularly important for high-availability services, showing how your metrics degrade across your execution context. For statistical significance, you need one "order of magnitude" more samples than your target percentile (100 samples for 0-99th percentile, 1,000 samples for 99.9th percentile). The toolbox for .NET performance measurement is rich and varied. Visual Studio Professional and higher versions include built-in profiling tools. Windows Performance Counters provide a simple way to monitor application and system performance. Event Tracing for Windows (ETW) offers a fundamental diagnostic logging system with comprehensive coverage of Windows components. PerfView, created by Microsoft .NET performance architect Vance Morrison, is particularly powerful for ETW collection and analysis, requiring no installation while providing extreme configurability and unparalleled stack analysis capabilities. Imagine being able to see exactly where your application spends its time, down to the microsecond-that's the power these tools provide when used properly.

第4章

Mastering the Garbage Collector

Garbage collection is often the first and last performance area developers address, as it's commonly perceived as the source of obvious performance problems. In reality, the .NET garbage collector provides better overall heap performance than native alternatives by handling allocation and fragmentation more effectively. The fundamental rule for high-performance GC programming is: "Collect objects in gen 0 or not at all." Objects should either have extremely short lifetimes (collected in gen 0) or stay in gen 2 forever. Collections become more expensive with each generation, so you want many fast gen 0 collections and very few expensive gen 2 collections. To optimize garbage collection performance, reduce allocation rates by critically examining each object to determine if it's truly necessary. Keep object lifespans short by allocating objects just before they're needed and ensuring they go out of scope as soon as possible after their last use. Avoid pinning, which fixes objects in place so the garbage collector cannot move them, as this increases heap fragmentation. Implement finalizers only when absolutely necessary, as they guarantee objects stay in memory even after collection. The Large Object Heap (LOH) requires special attention. Objects 85,000 bytes or larger are allocated on the LOH, which is more expensive to collect and prone to fragmentation. These allocations should be strictly controlled and ideally last for the program's lifetime. When LOH allocations are unavoidable, minimize fragmentation by standardizing allocation sizes. Use uniform buffer sizes or multiples of a standard size (like one megabyte) to increase the likelihood that freed memory can be reused rather than extending the heap. For applications that cannot tolerate gen 2 collection pauses, the GC notification mechanism allows preparation for imminent collections. This approach requires that full GCs are prohibitively expensive, you can quickly pause processing, other systems can handle work meanwhile, and gen 2 collections occur rarely.

『ハイパフォーマンス .NET 構造化プログラミング ――高速なコードを書くための実践的な手法』をもっと深く楽しむ

毎日の新しい気づきを10万件以上のレッスンから
言葉をハイライトして音声と同期
ライブラリを保存して、どの端末からでも利用

第5章

The Hidden Costs of JIT Compilation

When .NET code executes, it initially exists as Microsoft Intermediate Language (MSIL) in assemblies - a hardware-agnostic intermediate format. The Just-in-Time compiler performs the crucial task of converting this IL to native assembly instructions specific to the target hardware architecture. This JITting process occurs the first time a method is called, incurring a one-time performance hit. After compilation, the native code is cached in memory and executes directly with virtually no overhead on subsequent calls. Just-in-time compilation provides several significant advantages over traditional ahead-of-time compiled code. First, it dramatically improves locality of reference, as related code often ends up residing in the same memory pages. This spatial locality helps prevent expensive page faults during execution by keeping frequently accessed code close together. Second, JIT compilation reduces overall memory usage by only compiling methods that are actually executed during runtime - dead code remains as compact IL. Third, the JIT compiler can perform aggressive cross-assembly inlining, allowing methods from other DLLs (including the .NET Framework itself) to be inlined directly into your application code, enabling significant performance optimizations that wouldn't be possible with traditional static linking. However, JIT compilation time increases proportionally with code complexity and size. Many modern C# features can hide substantial amounts of code that require JITting. LINQ queries get transformed into multiple method calls and iterator blocks. The dynamic keyword generates complex runtime binding code. Regular expressions compile into state machines. Code generation through reflection or expression trees can produce large amounts of IL that needs compilation. Beyond pure JIT costs, assembly loading introduces additional overhead from disk I/O, construction of CLR data structures, and type metadata loading. To minimize JIT impact, developers should be particularly careful with large amounts of generated or dynamic code. Profile-guided optimization (PGO) can help decrease application startup time by pre-JITting the most frequently used code paths in parallel during application launch. To encourage function inlining - one of the JIT's most powerful optimizations - avoid virtual methods where possible, minimize exception handling blocks, reduce method size, and be cautious with recursion and complex loops. However, don't sacrifice application architecture and maintainability through premature optimization. The Native Image Generator (NGEN) tool offers an alternative by converting IL assemblies to native images stored in the Native Image Cache. While NGENed applications typically load faster by eliminating JIT overhead, they sacrifice some key benefits: they lose the locality of reference advantages of JIT compilation, can't perform certain runtime optimizations like cross-assembly inlining, and increase disk space usage. Additionally, NGEN images must be regenerated when .NET framework updates occur. For these reasons, NGEN should be considered only as a last resort when profile-guided optimization cannot meet performance requirements. Modern .NET also introduces ReadyToRun images - a hybrid approach that pre-compiles some code while retaining JIT flexibility for other parts. This provides a balance between startup performance and runtime optimization potential.

第6章

The Asynchronous Revolution

With multicore processors now ubiquitous across computing devices-from smartphones to servers-effective multithreaded programming has become an essential skill for modern developers. There are three primary motivations for employing multiple threads: preventing user interface blocking to maintain responsiveness, maximizing CPU utilization during I/O-bound operations, and fully leveraging all available processor cores for compute-intensive tasks. Each scenario requires different design approaches and considerations. The Task Parallel Library (TPL) represents a significant advancement in .NET concurrent programming by providing an efficient thread abstraction layer. Rather than creating new threads for each operation, TPL maximizes thread pool efficiency by executing multiple Tasks sequentially on the same thread when possible. This approach significantly reduces overhead compared to raw thread creation. TPL's true power lies in its continuation model-developers can execute multiple independent continuations for a single Task, chain them in precise sequences, conditionally execute them based on Task completion status, or coordinate multiple Tasks using ContinueWhenAll/ContinueWhenAny methods. This flexibility enables complex asynchronous workflows while maintaining code readability. Performance optimization in concurrent programming follows a cardinal rule: never waste one resource while waiting for another. Blocking threads during I/O operations creates two problematic scenarios: either thread unscheduling occurs (potentially forcing the creation of new threads to maintain throughput) or wasteful spinning on synchronization objects consumes CPU cycles. Both outcomes unnecessarily increase thread pool size and waste valuable system resources. Modern applications should strive for truly asynchronous I/O operations whenever possible. The introduction of async and await keywords in .NET 4.5 revolutionized asynchronous programming by transforming complex asynchronous patterns into code that closely resembles traditional synchronous flow-while maintaining non-blocking behavior throughout execution. Converting existing synchronous file operations to asynchronous implementations requires surprisingly minimal code changes-developers typically just add async to the method signature and await keywords before ReadAsync and WriteAsync method calls. This simple syntax masks the sophisticated state machine implementation handling the asynchronous transitions. Asynchronous programming exhibits a viral nature in codebases-once introduced at lower levels, it naturally propagates upward through the call stack as methods must become async-aware to properly handle async operations. Best practices strongly discourage blocking with Task.Wait() as this defeats the purpose of asynchronous execution, wastes thread pool threads, and increases context switching overhead. High-performance applications typically have the majority of their code running in continuations, efficiently responding to I/O completions or user input events. Thread synchronization becomes necessary when multiple threads access shared resources, commonly implemented through synchronization primitives like Monitor, Semaphore, and ManualResetEvent. A fundamental truth of concurrent programming remains: locking never improves performance-at best it's performance-neutral with well-implemented primitives and zero contention. However, we accept this performance cost because correctness must take precedence over raw speed in concurrent systems. Careful design can minimize lock contention through techniques like lock splitting, immutable data structures, and message-passing architectures.

聴きながら、すべての言葉を目で追えます

第7章

The Art of Class Design for Performance

Class design decisions can significantly impact performance. Classes are heap-allocated with pointer access and fixed overhead (8 bytes for 32-bit, 16 bytes for 64-bit processes), while structs have no overhead and can be stack-allocated. This difference becomes dramatic at scale: an array of 1 million objects with 16 bytes of data requires 28MB (32-bit) or 40MB+ (64-bit), while the same array of structs needs only 16MB. Overriding Equals and GetHashCode is crucial for structs. The default ValueType.Equals implementation uses reflection over all fields, causing significant performance overhead. Implement IEquatable<T> interface with a strongly-typed Equals(T other) method to avoid boxing and casting overhead. Don't mark methods virtual "just in case"-virtual methods prevent certain JIT optimizations, particularly inlining. Similarly, mark classes as sealed by default unless inheritance is needed. While the current JIT doesn't aggressively optimize sealed classes, this practice prepares your code for potential future compiler improvements. Boxing is the process of wrapping value types (primitives or structs) inside heap objects to pass them to methods requiring object references. This creates memory allocation overhead and requires garbage collection. Boxing costs CPU time for allocation, copying, and casting, and significantly increases GC pressure. Using standard for loops is significantly faster than foreach in many cases. When iterating over arrays, the compiler often converts simple foreach statements into standard for loops. However, when using IEnumerable interfaces, foreach becomes much more expensive, requiring virtual method calls, try-finally blocks, and memory allocation for the enumerator. Exceptions in .NET are extremely expensive-thousands of times slower than normal method execution. The ExceptionCost sample demonstrates that exceptions can be 8,000-12,000 times slower than empty methods. Reserve exceptions only for truly exceptional situations where performance is no longer the primary concern.

第8章

Navigating the .NET Framework for Performance

The .NET Framework, while powerful and versatile, was architected primarily for general-purpose use rather than raw performance optimization. This fundamental design choice means developers often need to implement specific workarounds in performance-critical code paths. The guiding principle remains straightforward but crucial: thoroughly understand the underlying code executing behind every API call you make. To effectively control performance, you must have intimate knowledge of what executes in every critical path - from memory allocation patterns to potential boxing operations. Collection types form a cornerstone of .NET development, with the framework providing over 21 built-in options, including thread-safe concurrent collections and strongly-typed generic versions. Older non-generic collections such as ArrayList, Hashtable, and Queue should be strictly avoided in performance-sensitive code due to their inherent boxing and casting costs. For example, storing an integer in ArrayList requires boxing it to an object, while retrieving it requires an unboxing operation and cast. Arrays remain the performance champions among collections, offering a compact, contiguous memory layout that significantly improves cache locality. This makes arrays particularly efficient for scenarios involving sequential access patterns or SIMD operations. String handling in .NET requires special attention because strings are immutable - once created, they exist unchanged until garbage collected. Any modification operation (concatenation, substring, replace, etc.) creates an entirely new string instance, potentially leading to memory fragmentation and increased garbage collection pressure. Efficient programs treat strings as opaque data blobs and minimize modifications. When possible, prefer non-string representations of data - for example, use DateTime for dates rather than string representations. The most efficient string comparison is no comparison at all - use enums or numeric data when possible. When string comparisons are unavoidable, employ the simplest method: String.Compare with StringComparison.Ordinal offers the best performance as it performs a pure binary comparison without cultural or case considerations. Exception handling in .NET comes with significant performance overhead. The framework must capture stack traces and maintain additional diagnostic information, making exceptions expensive operations that should be reserved for truly exceptional circumstances. Instead of relying on exception-throwing APIs, prefer TryPattern alternatives. For example, use Int32.TryParse instead of Int32.Parse, or DateTime.TryParse rather than DateTime.Parse. These methods return a boolean indicating success and output the parsed value through an out parameter, avoiding the overhead of FormatException for invalid inputs. For managing large or expensive-to-create objects that may not be needed in every program execution, the Lazy<T> wrapper provides an elegant solution. This pattern ensures the object is only initialized when the Value property is first accessed - a technique known as deferred initialization. For objects with parameterless constructors, use the simple Lazy<T> constructor. For more complex initialization scenarios, pass a Func<T> delegate that encapsulates the initialization logic. This approach is particularly valuable for objects that require database connections, file system access, or complex computation during initialization.

『ハイパフォーマンス .NET 構造化プログラミング ――高速なコードを書くための実践的な手法』をもっと深く楽しむ

毎日の新しい気づきを10万件以上のレッスンから
言葉をハイライトして音声と同期
ライブラリを保存して、どの端末からでも利用

第9章

Building a Performance Culture

Creating high-performance software requires team-wide commitment and a systematic approach to performance consciousness. As a performance expert, you'll need comprehensive strategies to elevate the entire team's capabilities and awareness. Start by building team consensus through data-driven discussions about which areas demand immediate performance focus and which can be addressed later. While all code deserves quality attention, critical performance areas-such as customer-facing APIs, data processing pipelines, and core business logic-should receive extra scrutiny and dedicated optimization efforts. Comprehensive testing forms the foundation of confident performance optimization. Beyond traditional functional tests, you need a robust suite of performance tests that track metrics across multiple dimensions. These should range from simple operation counts and memory allocation patterns to complex distributed system benchmarks running across server farms. Performance test failures should carry the same weight as functional failures in your CI/CD pipeline-blocking releases when they fall below established thresholds. Consider implementing automatic test runs that compare performance against both absolute targets and historical trends. Infrastructure investment is crucial for systematic performance management. Build tooling early to gather and analyze performance data across your entire stack. This might include PerfMon for single-machine diagnostics, custom performance counter aggregation for distributed systems, standardized benchmark suites for cross-team comparisons, automated profiling during test runs, performance-based alerting systems, and sophisticated ETW event analysis tools. While this infrastructure requires significant upfront investment, it pays enormous dividends by surfacing problems early and enabling data-driven optimization decisions. Proactive performance monitoring must replace reactive, complaint-driven optimization work. Establish clear metrics that directly correlate with user experience-response times, throughput, resource utilization, and application-specific measurements. Back every performance-related decision with concrete data, trending charts, and clear business impact analysis. This evidence-based approach builds credibility with stakeholders and transforms vague "it feels slow" complaints into specific, actionable improvements. Code review processes should evolve to support performance goals while remaining practical. Rather than exhaustive reviews of all code changes, implement tiered review processes based on performance impact. Critical paths might require detailed performance analysis and team reviews, while lower-impact changes can follow standard review procedures. For particularly complex performance-sensitive changes, schedule dedicated review sessions where the team can collaborate using shared tooling and visualization aids. Building a true performance culture requires ongoing education and mindset shifts. Establish regular training sessions-both formal and informal-to share performance best practices and pitfalls. Remember that developers from different backgrounds will need different guidance: experienced .NET developers might need to unlearn certain optimization patterns, while C/C++ veterans must adapt to managed code performance characteristics. Create a supportive environment for learning and experimentation, while gradually raising performance standards through clear guidelines and metrics. Ensure strong leadership support for these initiatives by demonstrating clear business value from performance improvements.

第10章

The Journey to High-Performance .NET

The path to high-performance .NET applications isn't about fighting against the framework or finding clever hacks - it's about understanding how the CLR works and aligning with its expectations. Success requires a deep comprehension of core runtime behaviors, from memory management patterns to execution models. By mastering garbage collection mechanics, optimizing JIT compilation pathways, embracing asynchronous programming patterns, designing classes with performance in mind, and using the .NET Framework judiciously, you can build applications that are both maintainable and blazingly fast. The journey begins with measurement - defining clear metrics and establishing quantifiable performance goals before diving into optimization work. This means setting up proper benchmarking frameworks like BenchmarkDotNet, establishing performance budgets, and implementing continuous performance monitoring. Teams need to track key indicators such as response times, throughput, memory usage patterns, and CPU utilization across different load conditions. Understanding the underlying systems is crucial for meaningful optimization. This includes knowledge of how the garbage collector generations work, when value types versus reference types are appropriate, and how to leverage struct layouts for better memory locality. Teams should be familiar with tools like PerfView and Visual Studio's diagnostic features to profile application behavior and identify bottlenecks effectively. The development of high-performance .NET applications requires establishing a performance-minded culture where the entire team is invested in building software that not only works correctly but performs exceptionally well. This means incorporating performance reviews into code reviews, maintaining performance test suites, and regularly discussing performance implications of architectural decisions. As demonstrated by Watson's experience at Microsoft - where .NET powers critical services handling millions of requests per second - the framework is more than capable of delivering exceptional performance at scale. Real-world examples include the Azure SignalR Service, which manages millions of concurrent WebSocket connections, and the high-throughput event processing systems in Azure Event Hubs, both built on .NET. Success stories from companies like Stack Overflow further reinforce this point - they serve millions of daily users with a relatively small number of servers running .NET applications. Their achievement comes from careful attention to performance fundamentals, strategic optimization, and thorough understanding of the platform's capabilities. The question isn't whether .NET can deliver high performance - it's whether development teams are willing to invest in understanding and properly utilizing the platform's full potential. This means committing to continuous learning about new framework features, performance best practices, and emerging optimization techniques while maintaining a balanced approach to code maintainability and performance optimization.

★★★★★

『ハイパフォーマンス .NET 構造化プログラミング ――高速なコードを書くための実践的な手法』を最後まで読み終えました

100万人以上の学習者に愛用されています

“23日間、毎日使い続けています。今では日課の一部です。”

jayallen

『ハイパフォーマンス .NET 構造化プログラミング ――高速なコードを書くための実践的な手法』の主要テーマ

garbage collection optimization
memory allocation patterns
just-in-time compilation
performance profiling tools
managed code efficiency

『ハイパフォーマンス .NET 構造化プログラミング ――高速なコードを書くための実践的な手法』の名言

The key insight is that we should work with the CLR, not against it.
"Measure, Measure, Measure!" is the most important rule.
Intuition can be dangerously misleading.
The default assumption should always be that the application needs fixing, not the framework.
Garbage collection is often the first and last performance area developers address.

『ハイパフォーマンス .NET 構造化プログラミング ――高速なコードを書くための実践的な手法』の登場人物

Ben WatsonAuthor and Microsoft Bing team engineer
Vance MorrisonMicrosoft .NET performance architect

著者について

Ben Watsonは、.NETアプリケーション最適化のベストセラーガイドである『Writing High-Performance .NET Code』の著者であり、高パフォーマンスなサーバーアーキテクチャの著名なエキスパートです。

2008年にMicrosoftに入社して以来、WatsonはBingプラットフォームチームのプリンシパルエンジニアを務め、数万台のマシンにわたって数百万件の大量かつ低遅延なリクエストを処理する、世界最大級の.NETベースのシステムの設計と構築を支援してきました。Bing、Cortana、Officeといったアプリケーションを支えてきた彼の実践的な経験は、.NETのパフォーマンス最適化およびエンタープライズ規模のソフトウェアエンジニアリングにおける第一人者としての地位を確立しています。

また、WatsonはSams出版の『C# 4.0 How-To』の著者でもあり、.NET RocksやNo Dogmaなどのポッドキャストで自身の知見を共有してきました。『Writing High-Performance .NET Code』の第2版では、Microsoftでの長年にわたる実世界の最適化経験を反映し、新しいツール、フレームワーク、高度なテクニックを盛り込むことで、初版から内容を50%拡充させています。

ハイパフォーマンス .NET 構造化プログラミング ――高速なコードを書くための実践的な手法の要約をダウンロード

ハイパフォーマンス .NET 構造化プログラミング ――高速なコードを書くための実践的な手法の要約をPDFまたはEPUBで無料でダウンロード。印刷やオフラインでいつでもお読みいただけます。

他のユーザーのお気に入り

Effective Programming

Jeff Atwood

Clean Code

Robert C. Martin

Senior C# Vocabulary and the Systems That Survive の書籍表紙

Design Patterns in C#: Which Ones Still Matter in 2026 | by Kerim Kara | Medium

Clean Architecture in C#: Practical Guide for .NET

.NET Architecture at Scale: Visual Guide to Modern Design Patterns | Nitin Singh | Enterprise AI & Architecture

6 sources

Senior C# Vocabulary and the Systems That Survive

Effective Java

Joshua Bloch

Programming C#

Jesse Liberty

High Performance Habits

Brendon Burchard

Hyperefficient

Mithu Storoni

You Should Test That

Chris Goward

この本に関するよくある質問

学習プラン

Build Atomic JSON:API in .NET

This plan is essential for .NET developers building high-performance, standardized APIs that require complex data handling. It benefits backend engineers looking to implement the JSON:API spec and its powerful atomic operations extension for transactional consistency.

1 h 15 m•3 セクション

学習プラン

Advanced SQL for Enterprise Performance

As data volumes grow, basic SQL is no longer sufficient for maintaining system stability and performance. This plan is designed for data engineers and backend developers who need to transition from writing queries to architecting high-performance, concurrent database solutions.

1 h 36 m•4 セクション

学習プラン

Designing and Programming Software

This comprehensive path is designed for developers looking to transition from writing scripts to engineering robust, production-ready systems. It provides the essential bridge between basic syntax and complex architectural decision-making required in modern tech roles.

5 h 53 m•4 セクション

学習プラン

Logic and Layout in Windows Forms

This plan is essential for developers looking to move beyond simple UI design into functional application architecture. It is ideal for those building desktop tools who need to balance intuitive user layouts with robust backend decision-making logic.

1 h•3 セクション

学習プラン

The High-Performance Engineer’s Social Blueprint

Technical excellence often plateaus without the social intelligence to navigate high-stakes environments. This plan is designed for engineers who want to bridge the gap between technical mastery and influential leadership through performance psychology and structured communication.

1 h 30 m•3 セクション

学習プラン

High-load Rust

This plan is designed for software engineers transitioning into systems programming where performance and reliability are non-negotiable. It bridges the gap between basic syntax and building high-throughput, production-grade services that leverage Rust's unique safety guarantees.

3 h 25 m•4 セクション

学習プラン

OpenAI Codex: The Non-Coder's Masterclass

As AI transforms software development, the ability to command code through natural language is becoming a vital superpower for non-technical professionals. This masterclass is designed for entrepreneurs and creators who want to build functional web applications without the traditional learning curve of programming languages.

1 h 12 m•3 セクション

学習プラン

Write Like You Mean It

This plan is essential for creators struggling with writer's block or inefficient workflows. It benefits aspiring writers and content marketers looking to combine psychological breakthroughs with modern AI tools to scale their output.

1 h 45 m•4 セクション

コロンビア大学卒業生がサンフランシスコで開発

LOVED BY

1,000,000+ curious minds.

4.7

avg rating

1M+ learners

"Instead of endless scrolling, I just hit play on BeFreed. It saves me so much time."

@Moemenn

"I never knew where to start with nonfiction—BeFreed’s book lists turned into podcasts gave me a clear path."

@Chloe, Solo founder, LA

117

"Perfect balance between learning and entertainment. Finished ‘Thinking, Fast and Slow’ on my commute this week."

@Raaaaaachelw

"Crazy how much I learned while walking the dog. BeFreed = small habits → big gains."

@Matt, YC alum

108

"Reading used to feel like a chore. Now it’s just part of my lifestyle."

@Erin, Investment Banking Associate , NYC

254

"Feels effortless compared to reading. I’ve finished 6 books this month already."

@djmikemoore

"BeFreed turned my guilty doomscrolling into something that feels productive and inspiring."

@Pitiful

4.5K

"BeFreed turned my commute into learning time. 20-min podcasts are perfect for finishing books I never had time for."

@SofiaP

"BeFreed replaced my podcast queue. Imagine Spotify for books — that’s it. 🙌"

@Jaded_Falcon

201

"It is great for me to learn something from the book without reading it."

@OojasSalunke

"The themed book list podcasts help me connect ideas across authors—like a guided audio journey."

@Leo, Law Student, UPenn

483

"Makes me feel smarter every time before going to work"

@Cashflowbubu

BeFreedがウェブ上でどのように話題になっているかをもっと見る

コロンビア大学卒業生がサンフランシスコで開発

LOVED BY

1,000,000+ curious minds.

4.7

avg rating

1M+ learners

"Instead of endless scrolling, I just hit play on BeFreed. It saves me so much time."

@Moemenn

"I never knew where to start with nonfiction—BeFreed’s book lists turned into podcasts gave me a clear path."

@Chloe, Solo founder, LA

117

"Perfect balance between learning and entertainment. Finished ‘Thinking, Fast and Slow’ on my commute this week."

@Raaaaaachelw

"Crazy how much I learned while walking the dog. BeFreed = small habits → big gains."

@Matt, YC alum

108

"Reading used to feel like a chore. Now it’s just part of my lifestyle."

@Erin, Investment Banking Associate , NYC

254

"Feels effortless compared to reading. I’ve finished 6 books this month already."

@djmikemoore

"BeFreed turned my guilty doomscrolling into something that feels productive and inspiring."

@Pitiful

4.5K

"BeFreed turned my commute into learning time. 20-min podcasts are perfect for finishing books I never had time for."

@SofiaP

"BeFreed replaced my podcast queue. Imagine Spotify for books — that’s it. 🙌"

@Jaded_Falcon

201

"It is great for me to learn something from the book without reading it."

@OojasSalunke

"The themed book list podcasts help me connect ideas across authors—like a guided audio journey."

@Leo, Law Student, UPenn

483

"Makes me feel smarter every time before going to work"

@Cashflowbubu

"Instead of endless scrolling, I just hit play on BeFreed. It saves me so much time."

@Moemenn

"I never knew where to start with nonfiction—BeFreed’s book lists turned into podcasts gave me a clear path."

@Chloe, Solo founder, LA

117

"Perfect balance between learning and entertainment. Finished ‘Thinking, Fast and Slow’ on my commute this week."

@Raaaaaachelw

"Crazy how much I learned while walking the dog. BeFreed = small habits → big gains."

@Matt, YC alum

108

"Reading used to feel like a chore. Now it’s just part of my lifestyle."

@Erin, Investment Banking Associate , NYC

254

"Feels effortless compared to reading. I’ve finished 6 books this month already."

@djmikemoore

"BeFreed turned my guilty doomscrolling into something that feels productive and inspiring."

@Pitiful

4.5K

"BeFreed turned my commute into learning time. 20-min podcasts are perfect for finishing books I never had time for."

@SofiaP

"BeFreed replaced my podcast queue. Imagine Spotify for books — that’s it. 🙌"

@Jaded_Falcon

201

"It is great for me to learn something from the book without reading it."

@OojasSalunke

"The themed book list podcasts help me connect ideas across authors—like a guided audio journey."

@Leo, Law Student, UPenn

483

"Makes me feel smarter every time before going to work"

@Cashflowbubu

"Instead of endless scrolling, I just hit play on BeFreed. It saves me so much time."

@Moemenn

"I never knew where to start with nonfiction—BeFreed’s book lists turned into podcasts gave me a clear path."

@Chloe, Solo founder, LA

117

"Perfect balance between learning and entertainment. Finished ‘Thinking, Fast and Slow’ on my commute this week."

@Raaaaaachelw

"Crazy how much I learned while walking the dog. BeFreed = small habits → big gains."

@Matt, YC alum

108

"Reading used to feel like a chore. Now it’s just part of my lifestyle."

@Erin, Investment Banking Associate , NYC

254

"Feels effortless compared to reading. I’ve finished 6 books this month already."

@djmikemoore

"BeFreed turned my guilty doomscrolling into something that feels productive and inspiring."

@Pitiful

4.5K

"BeFreed turned my commute into learning time. 20-min podcasts are perfect for finishing books I never had time for."

@SofiaP

"BeFreed replaced my podcast queue. Imagine Spotify for books — that’s it. 🙌"

@Jaded_Falcon

201

"It is great for me to learn something from the book without reading it."

@OojasSalunke

"The themed book list podcasts help me connect ideas across authors—like a guided audio journey."

@Leo, Law Student, UPenn

483

"Makes me feel smarter every time before going to work"

@Cashflowbubu

BeFreedがウェブ上でどのように話題になっているかをもっと見る

今すぐ学習の旅を始めよう

第6章

ハイパフォーマンス .NET 構造化プログラミング ――高速なコードを書くための実践的な手法

概要『ハイパフォーマンス .NET 構造化プログラミング ――高速なコードを書くための実践的な手法』の概要

1冊の本。さまざまな聴き方。

Unleashing the Power of Managed Code

The Surprising Truth About .NET Performance

聴きながら、すべての言葉を目で追えます

The Cardinal Rule: Measure, Measure, Measure!

Mastering the Garbage Collector

『ハイパフォーマンス .NET 構造化プログラミング ――高速なコードを書くための実践的な手法』をもっと深く楽しむ

The Hidden Costs of JIT Compilation

The Asynchronous Revolution

聴きながら、すべての言葉を目で追えます

The Art of Class Design for Performance

Navigating the .NET Framework for Performance

『ハイパフォーマンス .NET 構造化プログラミング ――高速なコードを書くための実践的な手法』をもっと深く楽しむ

Building a Performance Culture

The Journey to High-Performance .NET

『ハイパフォーマンス .NET 構造化プログラミング ――高速なコードを書くための実践的な手法』を最後まで読み終えました

『ハイパフォーマンス .NET 構造化プログラミング ――高速なコードを書くための実践的な手法』の主要テーマ

『ハイパフォーマンス .NET 構造化プログラミング ――高速なコードを書くための実践的な手法』の名言

『ハイパフォーマンス .NET 構造化プログラミング ――高速なコードを書くための実践的な手法』の登場人物

著者について

ハイパフォーマンス .NET 構造化プログラミング ――高速なコードを書くための実践的な手法の要約をダウンロード

他のユーザーのお気に入り

この本に関するよくある質問

What is Writing High-Performance .NET Code about?

Who is Ben Watson, author of Writing High-Performance .NET Code?

Who should read Writing High-Performance .NET Code?

Is Writing High-Performance .NET Code worth reading?

もっと見る

1,000,000+ curious minds.

1,000,000+ curious minds.

1冊の本。さまざまな聴き方。

Unleashing the Power of Managed Code

The Surprising Truth About .NET Performance

聴きながら、すべての言葉を目で追えます

The Cardinal Rule: Measure, Measure, Measure!

Mastering the Garbage Collector

『ハイパフォーマンス .NET 構造化プログラミング ――高速なコードを書くための実践的な手法』をもっと深く楽しむ

The Hidden Costs of JIT Compilation

The Asynchronous Revolution

聴きながら、すべての言葉を目で追えます

The Art of Class Design for Performance

Navigating the .NET Framework for Performance

『ハイパフォーマンス .NET 構造化プログラミング ――高速なコードを書くための実践的な手法』をもっと深く楽しむ

Building a Performance Culture

The Journey to High-Performance .NET

『ハイパフォーマンス .NET 構造化プログラミング ――高速なコードを書くための実践的な手法』を最後まで読み終えました

他のユーザーのお気に入り

もっと見る

『ハイパフォーマンス .NET 構造化プログラミング ――高速なコードを書くための実践的な手法』の概要