book

CLR via C#, Fourth Edition

Name: CLR via C#, Fourth Edition
Author: Jeffrey Richter
ISBN: 9780735668737

by Jeffrey Richter

November 2012

Intermediate to advanced

896 pages

32h 31m

English

Microsoft Press

Read now

Unlock full access

CLR via C#, Fourth Edition
Dedication
Foreword
Introduction
Who This Book Is ForAcknowledgmentsErrata & Book SupportWe Want to Hear from YouStay in Touch
I. CLR Basics
1. The CLR’s Execution Model
Compiling Source Code into Managed ModulesCombining Managed Modules into AssembliesLoading the Common Language RuntimeExecuting Your Assembly’s CodeIL and VerificationUnsafe CodeThe Native Code Generator Tool: NGen.exeThe Framework Class LibraryThe Common Type SystemThe Common Language SpecificationInteroperability with Unmanaged Code
2. Building, Packaging, Deploying, and Administering Applications and Types
.NET Framework Deployment GoalsBuilding Types into a ModuleResponse FilesA Brief Look at MetadataCombining Modules to Form an AssemblyAdding Assemblies to a Project by Using the Visual Studio IDEUsing the Assembly LinkerAdding Resource Files to an AssemblyAssembly Version Resource InformationVersion NumbersCultureSimple Application Deployment (Privately Deployed Assemblies)Simple Administrative Control (Configuration)
3. Shared Assemblies and Strongly Named Assemblies
Two Kinds of Assemblies, Two Kinds of DeploymentGiving an Assembly a Strong NameThe Global Assembly CacheBuilding an Assembly That References a Strongly Named AssemblyStrongly Named Assemblies Are Tamper-ResistantDelayed SigningPrivately Deploying Strongly Named AssembliesHow the Runtime Resolves Type ReferencesAdvanced Administrative Control (Configuration)Publisher Policy Control
II. Designing Types
4. Type Fundamentals
All Types Are Derived from System.ObjectCasting Between TypesCasting with the C# is and as OperatorsNamespaces and AssembliesHow Things Relate at Run Time

5. Primitive, Reference, and Value Types
Programming Language Primitive TypesChecked and Unchecked Primitive Type OperationsReference Types and Value TypesBoxing and Unboxing Value TypesChanging Fields in a Boxed Value Type by Using Interfaces (and Why You Shouldn’t Do This)Object Equality and IdentityObject Hash CodesThe dynamic Primitive Type
6. Type and Member Basics
The Different Kinds of Type MembersType VisibilityFriend AssembliesMember AccessibilityStatic ClassesPartial Classes, Structures, and InterfacesComponents, Polymorphism, and VersioningHow the CLR Calls Virtual Methods, Properties, and EventsUsing Type Visibility and Member Accessibility IntelligentlyDealing with Virtual Methods When Versioning Types
7. Constants and Fields
ConstantsFields
8. Methods
Instance Constructors and Classes (Reference Types)Instance Constructors and Structures (Value Types)Type ConstructorsOperator Overload MethodsOperators and Programming Language InteroperabilityConversion Operator MethodsExtension MethodsRules and GuidelinesExtending Various Types with Extension MethodsThe Extension AttributePartial MethodsRules and Guidelines
9. Parameters
Optional and Named ArgumentsRules and GuidelinesThe DefaultParameterValue and Optional AttributesImplicitly Typed Local VariablesPassing Parameters by Reference to a MethodPassing a Variable Number of Arguments to a MethodParameter and Return Type GuidelinesConst-ness
10. Properties
Parameterless PropertiesAutomatically Implemented PropertiesDefining Properties IntelligentlyObject and Collection InitializersAnonymous TypesThe System.Tuple TypeParameterful PropertiesThe Performance of Calling Property Accessor MethodsProperty Accessor AccessibilityGeneric Property Accessor Methods
11. Events
Designing a Type That Exposes an EventStep #1: Define a type that will hold any additional information that should be sent to receivers of the event notificationStep #2: Define the event memberStep #3: Define a method responsible for raising the event to notify registered objects that the event has occurredStep #4: Define a method that translates the input into the desired eventHow the Compiler Implements an EventDesigning a Type That Listens for an EventExplicitly Implementing an Event
12. Generics
Generics in the Framework Class LibraryGenerics InfrastructureOpen and Closed TypesGeneric Types and InheritanceGeneric Type IdentityCode ExplosionGeneric InterfacesGeneric DelegatesDelegate and Interface Contra-variant and Covariant Generic Type ArgumentsGeneric MethodsGeneric Methods and Type InferenceGenerics and Other MembersVerifiability and ConstraintsPrimary ConstraintsSecondary ConstraintsConstructor ConstraintsOther Verifiability IssuesCasting a Generic Type VariableSetting a Generic Type Variable to a Default ValueComparing a Generic Type Variable with nullComparing Two Generic Type Variables with Each OtherUsing Generic Type Variables as Operands
13. Interfaces
Class and Interface InheritanceDefining an InterfaceInheriting an InterfaceMore About Calling Interface MethodsImplicit and Explicit Interface Method Implementations (What’s Happening Behind the Scenes)Generic InterfacesGenerics and Interface ConstraintsImplementing Multiple Interfaces That Have the Same Method Name and SignatureImproving Compile-Time Type Safety with Explicit Interface Method ImplementationsBe Careful with Explicit Interface Method ImplementationsDesign: Base Class or Interface?
III. Essential Types
14. Chars, Strings, and Working with Text
CharactersThe System.String TypeConstructing StringsStrings Are ImmutableComparing StringsString InterningString PoolingExamining a String’s Characters and Text ElementsOther String OperationsConstructing a String EfficientlyConstructing a StringBuilder ObjectStringBuilder MembersObtaining a String Representation of an Object: ToStringSpecific Formats and CulturesFormatting Multiple Objects into a Single StringProviding Your Own Custom FormatterParsing a String to Obtain an Object: ParseEncodings: Converting Between Characters and BytesEncoding and Decoding Streams of Characters and BytesBase-64 String Encoding and DecodingSecure Strings
15. Enumerated Types and Bit Flags
Enumerated TypesBit FlagsAdding Methods to Enumerated Types
16. Arrays
Initializing Array ElementsCasting ArraysAll Arrays Are Implicitly Derived from System.ArrayAll Arrays Implicitly Implement IEnumerable, ICollection, and IListPassing and Returning ArraysCreating Non-Zero Lower Bound ArraysArray InternalsUnsafe Array Access and Fixed-Size Array
17. Delegates
A First Look at DelegatesUsing Delegates to Call Back Static MethodsUsing Delegates to Call Back Instance MethodsDemystifying DelegatesUsing Delegates to Call Back Many Methods (Chaining)C#’s Support for Delegate ChainsHaving More Control over Delegate Chain InvocationEnough with the Delegate Definitions Already (Generic Delegates)C#’s Syntactical Sugar for DelegatesSyntactical Shortcut #1: No Need to Construct a Delegate ObjectSyntactical Shortcut #2: No Need to Define a Callback Method (Lambda Expressions)Syntactical Shortcut #3: No Need to Wrap Local Variables in a Class Manually to Pass Them to a Callback MethodDelegates and Reflection
18. Custom Attributes
Using Custom AttributesDefining Your Own Attribute ClassAttribute Constructor and Field/Property Data TypesDetecting the Use of a Custom AttributeMatching Two Attribute Instances Against Each OtherDetecting the Use of a Custom Attribute Without Creating Attribute-Derived ObjectsConditional Attribute Classes
19. Nullable Value Types
C#’s Support for Nullable Value TypesC#’s Null-Coalescing OperatorThe CLR Has Special Support for Nullable Value TypesBoxing Nullable Value TypesUnboxing Nullable Value TypesCalling GetType via a Nullable Value TypeCalling Interface Methods via a Nullable Value Type
IV. Core Facilities
20. Exceptions and State Management
Defining “Exception”Exception-Handling MechanicsThe try BlockThe catch BlockThe finally BlockThe System.Exception ClassFCL-Defined Exception ClassesThrowing an ExceptionDefining Your Own Exception ClassTrading Reliability for ProductivityGuidelines and Best PracticesUse finally Blocks LiberallyDon’t Catch EverythingRecovering Gracefully from an ExceptionBacking Out of a Partially Completed Operation When an Unrecoverable Exception Occurs—Maintaining StateHiding an Implementation Detail to Maintain a “Contract”Unhandled ExceptionsDebugging ExceptionsException-Handling Performance ConsiderationsConstrained Execution Regions (CERs)Code Contracts
21. The Managed Heap and Garbage Collection
Managed Heap BasicsAllocating Resources from the Managed HeapThe Garbage Collection AlgorithmGarbage Collections and DebuggingGenerations: Improving PerformanceGarbage Collection TriggersLarge ObjectsGarbage Collection ModesForcing Garbage CollectionsMonitoring Your Application’s Memory UsageWorking with Types Requiring Special CleanupUsing a Type That Wraps a Native ResourceAn Interesting Dependency IssueOther GC Features for Use with Native ResourcesFinalization InternalsMonitoring and Controlling the Lifetime of Objects Manually
22. CLR Hosting and AppDomains
CLR HostingAppDomainsAccessing Objects Across AppDomain BoundariesDemo #1: Cross-AppDomain Communication Using Marshal-by-ReferenceDemo #2: Cross-AppDomain Communication Using Marshal-by-ValueDemo #3: Cross-AppDomain Communication Using Non-Marshalable TypesAppDomain UnloadingAppDomain MonitoringAppDomain First-Chance Exception NotificationsHow Hosts Use AppDomainsExecutable ApplicationsMicrosoft Silverlight Rich Internet ApplicationsMicrosoft ASP.NET and XML Web Services ApplicationsMicrosoft SQL ServerYour Own ImaginationAdvanced Host ControlManaging the CLR by Using Managed CodeWriting a Robust Host ApplicationHow a Host Gets Its Thread Back
23. Assembly Loading and Reflection
Assembly LoadingUsing Reflection to Build a Dynamically Extensible ApplicationReflection PerformanceDiscovering Types Defined in an AssemblyWhat Exactly Is a Type Object?Building a Hierarchy of Exception-Derived TypesConstructing an Instance of a TypeDesigning an Application That Supports Add-InsUsing Reflection to Discover a Type’s MembersDiscovering a Type’s MembersInvoking a Type’s MembersUsing Binding Handles to Reduce Your Process’s Memory Consumption
24. Runtime Serialization
Serialization/Deserialization Quick StartMaking a Type SerializableControlling Serialization and DeserializationHow Formatters Serialize Type InstancesControlling the Serialized/Deserialized DataHow to Define a Type That Implements ISerializable When the Base Type Doesn’t Implement This InterfaceStreaming ContextsSerializing a Type As a Different Type and Deserializing an Object As a Different ObjectSerialization SurrogatesSurrogate Selector ChainsOverriding the Assembly and/or Type When Deserializing an Object
25. Interoperating with WinRT Components
CLR Projections and WinRT Component Type System RulesWinRT Type System Core ConceptsFramework ProjectionsCalling Asynchronous WinRT APIs from .NET CodeInteroperating Between WinRT Streams and .NET StreamsPassing Blocks of Data Between the CLR and WinRTDefining WinRT Components in C#
V. Threading
26. Thread Basics
Why Does Windows Support Threads?Thread OverheadStop the MadnessCPU TrendsCLR Threads and Windows ThreadsUsing a Dedicated Thread to Perform an Asynchronous Compute-Bound OperationReasons to Use ThreadsThread Scheduling and PrioritiesForeground Threads vs. Background ThreadsWhat Now?
27. Compute-Bound Asynchronous Operations
Introducing the CLR’s Thread PoolPerforming a Simple Compute-Bound OperationExecution ContextsCooperative Cancellation and TimeoutTasksWaiting for a Task to Complete and Getting Its ResultCanceling a TaskStarting a New Task Automatically When Another Task CompletesA Task May Start Child TasksInside a TaskTask FactoriesTask SchedulersParallel’s Static For, ForEach, and Invoke MethodsParallel Language Integrated QueryPerforming a Periodic Compute-Bound OperationSo Many Timers, So Little TimeHow the Thread Pool Manages Its ThreadsSetting Thread Pool LimitsHow Worker Threads Are Managed
28. I/O-Bound Asynchronous Operations
How Windows Performs I/O OperationsC#’s Asynchronous FunctionsHow the Compiler Transforms an Async Function into a State MachineAsync Function ExtensibilityAsync Functions and Event HandlersAsync Functions in the Framework Class LibraryAsync Functions and Exception HandlingOther Async Function FeaturesApplications and Their Threading ModelsImplementing a Server AsynchronouslyCanceling I/O OperationsSome I/O Operations Must Be Done SynchronouslyFileStream-Specific IssuesI/O Request Priorities
29. Primitive Thread Synchronization Constructs
Class Libraries and Thread SafetyPrimitive User-Mode and Kernel-Mode ConstructsUser-Mode ConstructsVolatile ConstructsC#’s Support for Volatile FieldsInterlocked ConstructsImplementing a Simple Spin LockThe Interlocked Anything PatternKernel-Mode ConstructsEvent ConstructsSemaphore ConstructsMutex Constructs
30. Hybrid Thread Synchronization Constructs
A Simple Hybrid LockSpinning, Thread Ownership, and RecursionHybrid Constructs in the Framework Class LibraryThe ManualResetEventSlim and SemaphoreSlim ClassesThe Monitor Class and Sync BlocksThe ReaderWriterLockSlim ClassThe OneManyLock ClassThe CountdownEvent ClassThe Barrier ClassThread Synchronization Construct SummaryThe Famous Double-Check Locking TechniqueThe Condition Variable PatternAsynchronous SynchronizationThe Concurrent Collection Classes
Index
About the Author
Copyright

Content preview from CLR via C#, Fourth Edition

Chapter 2. Building, Packaging, Deploying, and Administering Applications and Types

In this chapter:

.NET Framework Deployment Goals

Building Types into a Module

A Brief Look at Metadata

Combining Modules to Form an Assembly

Assembly Version Resource Information

Culture

Simple Application Deployment (Privately Deployed Assemblies)

Simple Administrative Control (Configuration)

Before we get into the chapters that explain how to develop programs for the Microsoft .NET Framework, let’s discuss the steps required to build, package, and deploy your applications and their types. In this chapter, I’ll focus on the basics of how to build assemblies that are for your application’s sole use. In Chapter 3, I’ll cover the more advanced concepts you’ll need to understand, ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9780735668737Purchase book

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

CLR via C#, Fourth Edition

by Jeffrey Richter

Chapter 2. Building, Packaging, Deploying, and Administering Applications and Types

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.