NET Framework Notes For Professionals. 100+ pages of professional hints and tricks (GoalKicker.com) (Z-Library)

# .NET Framework Notes For Professionals ## 【One-Line Pitch】 A practical, recipe-style reference for .NET developers who want quick answers to everyday coding problems—covering everything from strings and collections to LINQ, reflection, and interop—without wading through lengthy tutorials. Ideal for intermediate programmers who need a compact desk reference for the classic .NET Framework. ## 【Book Arc】 - **Opening (~0%–10%)**: The book opens with "Hello World" examples across multiple .NET languages (C#, F#, VB.NET, C++/CLI, IL, PowerShell, and more), establishing that this is a multi-language reference. It then dives into fundamental topics like strings—covering character counting, encoding conversion, comparison, splitting, and the immutability of strings. - **Early (~10%–29%)**: Core collection types take center stage: Dictionaries (including ConcurrentDictionary with Lazy for thread-safe lazy initialization), Collections (initializers, Stack, Queue, custom-type Lists), and ReadOnlyCollections (with an important warning that elements inside are not inherently read-only). This section also explains the stack vs. heap distinction for value and reference types. - **Early (~13%–29%)**: The largest single topic is LINQ, with dozens of short sections covering projection (Select, SelectMany), filtering (Where, OfType), aggregation (Aggregate, Max, Average), ordering (OrderBy, ThenBy), partitioning (Skip, Take), and set operations (Union, Except). Each operator gets a minimal, focused example. - **Early (~29%–32%)**: Reflection and Expression Trees are introduced for dynamic programming scenarios—comparing objects, creating instances at runtime, reading enum attributes with caching, and building predicate expressions programmatically. Custom types (struct vs. class) and Code Contracts for design-by-contract development follow. - **Middle (~32%–48%)**: The book shifts to configuration and I/O: reading AppSettings across .NET versions, strongly-typed settings, regular expressions, file operations via System.IO, ZIP file reading/writing, and the Managed Extensibility Framework (MEF) for plugin architectures. Speech recognition and memory caching make brief appearances. - **Middle (~48%–end)**: Advanced topics include dynamic assembly generation with System.Reflection.Emit, P/Invoke and marshaling for Win32 interop (unions, arrays, calling DLL functions), and NuGet package management—installing, uninstalling, and configuring package sources. ## 【Key Takeaways】 - **Strings are immutable—plan around it** (Opening): Every string operation creates a new instance, so repeated concatenation in loops is costly. Use StringBuilder for heavy string building, and understand encoding conversions when working with different text formats. - **ReadOnlyCollection protects the wrapper, not the contents** (Early): A ReadOnlyCollection prevents adding/removing items, but the objects inside can still be mutated if they're reference types. This is a critical distinction for API design and defensive coding. - **ConcurrentDictionary + Lazy prevents duplicate computation** (Early): Combining ConcurrentDictionary with Lazy<T> ensures that expensive factory operations run only once even under concurrency, avoiding the classic "check-then-act" race condition. - **LINQ is a toolbox of composable operations** (Early): The sheer variety—Select, Where, GroupBy, Join, Zip, Aggregate, and dozens more—means most data transformations can be expressed declaratively. Learning which operator fits which scenario (e.g., Single vs. First, SelectMany for flattening) is the key to readable code. - **Reflection enables dynamic behavior at runtime** (Early): Creating objects from types discovered at runtime, comparing objects generically, and reading attributes are all possible—but expensive. Cache reflection results (like enum attributes) to avoid repeated performance penalties. - **Expression Trees let you build code as data** (Early): Constructing predicates like `field == value` at runtime enables scenarios like dynamic query building. The C# compiler itself generates expression trees for lambdas, which frameworks can inspect and translate. - **Code Contracts formalize design assumptions** (Early): Preconditions and postconditions turn runtime checks into declarative, verifiable contracts—especially useful for interface implementations where multiple classes must honor the same rules. - **P/Invoke and marshaling bridge managed and unmanaged worlds** (Middle): Calling Win32 functions, marshaling unions and arrays, and using Windows APIs are all covered with practical patterns. This is essential knowledge for interop scenarios, but requires careful attention to memory layout and calling conventions. ## 【Reading Tips】 - **Use this as a lookup reference, not a cover-to-cover read**: The book is organized as discrete, self-contained sections. Skim the table of contents and jump directly to the topic you need—each section is designed to be read in isolation. - **Deep-read the LINQ chapter**: It's the largest and most valuable section. Even if you know the basics, the sheer number of operators (40+) means you'll likely discover a few you haven't used—like Zip, Except, or OfType—that could simplify your code. - **Pay attention to the "gotcha" sections**: The warning about ReadOnlyCollection elements and the immutability of strings are the kind of subtle pitfalls that cause production bugs. These short callouts are worth more than many longer tutorials. - **Skim the multi-language Hello World examples**: Unless you're specifically working in F#, VB.NET, or C++/CLI, these are low-value. The C# and IL examples are mildly interesting for understanding compilation, but the rest is filler for most readers. - **For modern .NET developers, note the historical context**: Some sections reference older .NET versions (like ConfigurationSettings in 1.x). If you're on .NET Core or .NET 5+, verify whether the APIs mentioned are still current or have been replaced. ## 【Coverage Limits】 This guide is based on a sample of the book's table of contents and section headers (approximately 48% of the book). The excerpts do not cover the full content of later chapters, including complete code examples, the regular expressions chapter in depth, or any final chapters beyond NuGet packaging. Specific code samples and detailed explanations for each section are not included in this guide. ##