Share
Create bookmark
CLR via C#
Do you like this document?
Notes
Please login to add notes
- + Cover
- Dedication
- Contents at a Glance
- Contents
- Foreword
- + Introduction
-
+
Part I: CLR Basics
-
+
Chapter 1: The CLR’s Execution Model
- Compiling Source Code into Managed Modules
- Combining Managed Modules into Assemblies
- Loading the Common Language Runtime
- + Executing Your Assembly’s Code
- The Native Code Generator Tool: NGen.exe
- Introducing the Framework Class Library
- The Common Type System
- The Common Language Specification
- Interoperability with Unmanaged Code
- + Chapter 2: Building, Packaging, Deploying, and Administering Applications and Types
-
+
Chapter 3: Shared Assemblies and Strongly Named Assemblies
- Two Kinds of Assemblies, Two Kinds of Deployment
- Giving an Assembly a Strong Name
- + The Global Assembly Cache
- Building an Assembly that References a Strongly Named Assembly
- Strongly Named Assemblies Are Tamper-Resistant
- Delayed Signing
- Privately Deploying Strongly Named Assemblies
- How the Runtime Resolves Type References
- + Advanced Administrative Control (Configuration)
-
+
Chapter 1: The CLR’s Execution Model
- + Part II: Working with Types
-
+
Part III: Designing Types
-
+
Chapter 6: Type and Member Basics
- + Chapter 7: Constants and Fields
-
+
Chapter 8: Methods: Constructors, Operators, Conversions, and Parameters
- Instance Constructors and Classes (Reference Types)
- Instance Constructors and Structures (Value Types)
- + Type Constructors
- + Operator Overload Methods
- Conversion Operator Methods
- Passing Parameters by Reference to a Method
- Passing a Variable Number of Arguments to a Method
- Declaring a Method’s Parameter Types
- Constant Methods and Parameters
- + Chapter 9: Properties
-
+
Chapter 10: Events
-
+
Designing a Type That Exposes an Event
- Step #1: Define a type that will hold any additional information that should be sent to receivers of the event notification
- Step #2: Define the event member
- Step #3: Define a method responsible for raising the event to notify registered objects that the event has occurred
- Step #4: Define a method that translates the input into the desired event
- How Events Are Implemented
- Designing a Type That Listens for an Event
- Events and Thread Safety
- Explicitly Controlling Event Registration and Unregistration
- Designing a Type That Defines Lots of Events
-
+
Designing a Type That Exposes an Event
-
+
Chapter 6: Type and Member Basics
-
+
Part IV: Essential Types
- + Chapter 11: Chars, Strings, and Working with Text
- + Chapter 12: Enumerated Types and Bit Flags
- + Chapter 13: Arrays
-
+
Chapter 14: Interfaces
- Class and Interface Inheritance
- Defining an Interface
- Inheriting an Interface
- More About Calling Interface Methods
- Implicit and Explicit Interface Method Implementations (What’s Happening Behind the Scenes)
- Generic Interfaces
- Generics and Interface Constraints
- Implementing Multiple Interfaces That Have the Same Method Name and Signature
- Improving Compile-Time Type Safety with Explicit Interface Method Implementations
- Be Careful with Explicit Interface Method Implementations
- Design: Base Class or Interface?
-
+
Chapter 15: Delegates
- A First Look at Delegates
- Using Delegates to Call Back Static Methods
- Using Delegates to Call Back Instance Methods
- Demystifying Delegates
- + Using Delegates to Call Back Many Methods (Chaining)
-
+
C#’s Syntactical Sugar for Delegates
- Syntactical Shortcut #1: No Need to Construct a Delegate Object
- Syntactical Shortcut #2: No Need to Define a Callback Method
- Syntactical Shortcut #3: No Need to Specify Callback Method Parameters
- Syntactical Shortcut #4: No Need to Manually Wrap Local Variables in a Class to Pass them to a Callback Method
- Delegates and Reflection
-
+
Chapter 16: Generics
-
+
Chapter 17: Custom Attributes
- Using Custom Attributes
- Defining Your Own Attribute Class
- Attribute Constructor and Field/Property Data Types
- Detecting the Use of a Custom Attribute
- Matching Two Attribute Instances Against Each Other
- Detecting the Use of a Custom Attribute Without Creating Attribute-Derived Objects
- Conditional Attribute Classes
-
+
Chapter 18: Nullable Value Types
-
+
Part V: CLR Facilities
-
+
Chapter 19: Exceptions
- The Evolution of Exception Handling
- + The Mechanics of Exception Handling
- Common Language Specification (CLS) and Non-CLS Exceptions
- What Exactly Is an Exception?
- The System.Exception Class
- FCL-Defined Exception Classes
- Throwing an Exception
- Defining Your Own Exception Class
- + How to Use Exceptions Properly
- Performance Considerations
- Unhandled Exceptions
- Exception Stack Traces
- Debugging Exceptions
-
+
Chapter 20: Automatic Memory Management (Garbage Collection)
- + Understanding the Basics of Working in a Garbage-Collected Platform
- The Garbage Collection Algorithm
- Garbage Collections and Debugging
- + Using Finalization to Release Native Resources
- Using Finalization with Managed Resources
- What Causes Finalize Methods to Be Called
- Finalization Internals
- The Dispose Pattern: Forcing an Object to Clean Up
- Using a Type That Implements the Dispose Pattern
- C#’s using Statement
- An Interesting Dependency Issue
- Manually Monitoring and Controlling the Lifetime of Objects
- Resurrection
- Generations
- Other Garbage Collection Features for Use with Native Resources
- Predicting the Success of an Operation that Requires a Lot of Memory
- Programmatic Control of the Garbage Collector
- + Other Garbage Collector Performance Topics
- Monitoring Garbage Collections
-
+
Chapter 21: CLR Hosting and AppDomains
-
+
Chapter 22: Assembly Loading and Reflection
-
+
Chapter 23: Performing Asynchronous Operations
- How the CLR Uses Windows Threads
- Pontificating about Efficient Thread Usage
- Introducing the CLR’s Thread Pool
- Limiting the Number of Threads in the Thread Pool
- Using the Thread Pool to Perform an Asynchronous Compute-Bound Operation
- Using a Dedicated Thread to Perform an Asynchronous Compute-Bound Operation
- + Periodically Performing an Asynchronous Compute-Bound Operation
- Introducing the Asynchronous Programming Model
- Using the APM to Perform an Asynchronous I/O-Bound Operation
- + The APM’s Three Rendezvous Techniques
- Using the APM to Perform an Asynchronous Compute-Bound Operation
- The APM and Exceptions
- Important Notes about the APM
- Execution Contexts
-
+
Chapter 24: Thread Synchronization
- + Memory Consistency, Volatile Memory Access, and Volatile Fields
- The Interlocked Methods
-
+
The Monitor Class and Sync Blocks
- The “Great” Idea
- Implementing the “Great” Idea
- Using the Monitor Class to Manipulate a Sync Block
- Synchronizing the Way Microsoft Intended
- Simplifying the Code with C#’s lock Statement
- Synchronizing Static Members the Way Microsoft Intended
- Why the “Great” Idea Isn’t So Great After All
- The Famous Double-Check Locking Technique
- The ReaderWriterLock Class
- + Using Windows Kernel Objects from Managed Code
-
+
Chapter 19: Exceptions
- + Index
- Author Biography
Dig deep and master the intricacies of the common language runtime (CLR) and the .NET Framework. Written by a highly regarded programming expert and consultant to the Microsoft .NET team, this guide is ideal for developers building any kind of application—including Microsoft ASP.NET, Windows Forms, Microsoft SQL Server, Web services, and console applications. You’ll get hands-on instruction and extensive code C# code samples to help you tackle the tough topics and develop high-performance applications. Discover how to: Build, deploy, administer, and version applications, components, and shared assemblies Design types using constants, fields, constructors, methods, properties, and events Work effectively with the CLR’s special types including enumerators, arrays, and strings Declare, create, and use delegates to expose callback functions Define and employ re-usable algorithms with interfaces and generics Define, use, and detect custom attributes Use exception handling to build robust, reliable, and security-enhanced components Manage memory automatically with the garbage collector and work with native resources Apply CLR Hosting, AppDomains, assembly loading, and reflection to build dynamically extensible applications PLUS—Get code samples on the Web
Your free to read time expires in minutes. After that you have to pause for an hour.
Test the closed alpha on paperc.com
Book Details
Authors
Categories
Computers > Programming Languages > C#
Publishers
Publication year : 2009
License: All rights reserved ©
Times read: 141
