book

Programming .NET Components, 2nd Edition

Name: Programming .NET Components, 2nd Edition
Author: Juval Lowy
ISBN: 9780596102074

by Juval Lowy

July 2005

Intermediate to advanced

644 pages

17h

English

O'Reilly Media, Inc.

Read now

Unlock full access

Programming .NET Components, 2nd Edition
Dedication
A Note Regarding Supplemental Files
Preface
Scope of This Book
Some Assumptions About the Reader
Conventions Used in This Book
Comments and Questions
Safari Enabled
Acknowledgments

1. Introducing Component-Oriented Programming
1.1. Basic Terminology
1.2. Component-Oriented Versus Object-Oriented Programming
1.2.1. Building Blocks Versus Monolithic Applications1.2.2. Interfaces Versus Inheritance
1.3. Principles of Component-Oriented Programming
1.3.1. Separation of Interface from Implementation1.3.2. Binary Compatibility Between Client and Server1.3.3. Language Independence1.3.4. Location Transparency1.3.5. Concurrency Management1.3.6. Versioning Support1.3.7. Component-Based Security
1.4. .NET Adherence to Component Principles
1.5. Developing .NET Components
1.5.1. The .NET Base Classes1.5.2. Declarative Programming1.5.3. Component-Oriented Security1.5.4. Simplified Deployment
2. .NET Component-Oriented Programming Essentials
2.1. Language Independence: The CLR
2.1.1. Intermediate Language and the JIT Compiler2.1.2. .NET Programming Languages2.1.3. .NET Components Are Language-Independent2.1.4. Choosing a .NET Language
2.2. Packaging and Deployment: Assemblies
2.2.1. DLLs and COM Components2.2.2. .NET Assemblies2.2.3. Assemblies and Visual Studio 20052.2.3.1. Partial types2.2.3.2. Adding a reference2.2.3.3. The reference path2.2.3.4. Aliasing a reference2.2.3.5. The Visual Studio 2005 assembly host2.2.4. Client and Server Assemblies2.2.5. Managing Component Visibility in Assemblies2.2.6. Assembly Metadata2.2.7. The Assembly Manifest2.2.8. Friend Assemblies2.2.9. Composing Assemblies2.2.10. The Assembly Type
2.3. Binary Compatibility
2.3.1. COM Binary Compatibility2.3.2. .NET Binary Compatibility2.3.3. Binary Inheritance
3. Interface-Based Programming
3.1. Separating Interface from Implementation
3.1.1. Interface Implementation3.1.2. Explicit Interface Implementation
3.2. Working with Interfaces
3.2.1. Interfaces and Type Safety3.2.2. Interface Methods, Properties, and Events3.2.3. Interfaces and Structs3.2.4. Interfaces and Partial Types3.2.5. Implementing Multiple Interfaces3.2.6. Interfaces and Class Hierarchies
3.3. Interfaces and Generics
3.3.1. Deriving from a Generic Interface3.3.2. Explicit Generic Interface Implementation3.3.3. Generic Interfaces as Operators3.3.4. Interface-Level Constraints3.3.5. Generic Derivation Constraints3.3.6. Generics, Interfaces, and Casting3.3.7. Generic Interface Methods
3.4. Designing and Factoring Interfaces
3.4.1. Interface Factoring3.4.2. Factoring Metrics
3.5. Interfaces in Visual Studio 2005
3.5.1. Interface Refactoring
4. Lifecycle Management
4.1. The Managed Heap
4.2. Traditional Memory De-allocation Schemas
4.3. .NET Garbage Collection
4.4. Object Finalization
4.4.1. Explicit Garbage Collection4.4.2. Finalize() Method Implementation
4.5. Deterministic Finalization
4.5.1. The Open/Close Pattern4.5.2. The Dispose() Pattern4.5.3. The IDisposable Pattern4.5.4. Disposing and Error Handling4.5.4.1. The using statement and interfaces4.5.4.2. The using statements and generics4.5.5. Dispose() and Finalize()4.5.6. Deterministic Finalization Template
5. Versioning
5.1. Assembly Version Number
5.1.1. Version Number Elements5.1.2. Providing the Version Number
5.2. Assembly Deployment Models
5.3. Strong Assembly Names
5.3.1. Signing Your Assembly5.3.1.1. Generating a strong name key file5.3.1.2. Selecting an existing strong name key file5.3.1.3. Handling large organizations’ keys5.3.2. Strong Names and Private Assemblies5.3.3. Friend Assemblies and Strong Names5.3.4. Installing a Shared Assembly5.3.4.1. Verifying shared assembly mode5.3.4.2. Side-by-side execution
5.4. Visual Studio 2005 and Versioning
5.4.1. Specific Reference Version
5.5. Custom Version Policies
5.5.1. Application Custom Policies5.5.1.1. Custom version-binding policies5.5.1.2. Custom codebase policies5.5.1.3. Application configuration file5.5.2. Global Custom Policies
5.6. CLR Versioning
5.6.1. CLR Side-by-Side Execution5.6.2. Version Unification5.6.3. Specifying a CLR Version5.6.3.1. Default version binding5.6.3.2. Specifying supported CLR versions
6. Events
6.1. Delegate-Based Events
6.1.1. Delegate Inference6.1.2. Generic Delegates6.1.3. The event Keyword6.1.4. Events in Visual Basic 2005
6.2. Working with .NET Events
6.2.1. Defining Delegate Signatures6.2.2. Defining Custom Event Arguments6.2.3. The Generic Event Handler6.2.4. Publishing Events Defensively6.2.4.1. The EventsHelper class6.2.4.2. Making EventsHelper type-safe6.2.5. Event Accessors6.2.6. Managing Large Numbers of Events6.2.7. Writing Sink Interfaces
7. Asynchronous Calls
7.1. Requirements for an Asynchronous Mechanism
7.2. Revisiting Delegates
7.3. Asynchronous Call Programming Models
7.3.1. Using BeginInvoke() and EndInvoke()7.3.1.1. The IAsyncResult interface7.3.1.2. The AsyncResult class7.3.1.3. Polling or waiting for completion7.3.2. Using Completion Callback Methods7.3.2.1. Callback methods and thread safety7.3.2.2. Passing state information7.3.3. Performing Asynchronous Operations Without Delegates
7.4. Asynchronous Error Handling
7.5. Asynchronous Events
7.5.1. Asynchronous EventsHelper7.5.1.1. Type-safe asynchronous EventsHelper
7.6. Asynchronous Invocation Pitfalls
7.6.1. Threading Concurrency and Synchronization7.6.2. Thread-Pool Exhaustion7.6.3. Premature Access by Reference and Reference Types7.6.4. Lengthy Constructors7.6.5. Cleaning Up After EndInvoke
7.7. Synchronous Versus Asynchronous Processing
8. Multithreading and Concurrency Management
8.1. Threads and Multithreading
8.2. Components and Threads
8.3. Working with Threads
8.3.1. Creating Threads8.3.1.1. Designing thread methods8.3.2. Blocking Threads8.3.2.1. Suspending and resuming a thread8.3.2.2. Putting a thread to sleep8.3.2.3. Spinning while waiting8.3.2.4. Joining a thread8.3.2.5. Interrupting a waiting thread8.3.3. Aborting a Thread8.3.4. Thread States8.3.5. Foreground and Background Threads8.3.6. Thread Priority and Scheduling
8.4. Synchronizing Threads
8.5. Automatic Synchronization
8.5.1. Synchronization Domains8.5.2. Synchronization Domains and Contexts8.5.3. Configuring Synchronization Domains8.5.3.1. Synchronization NOT_SUPPORTED8.5.3.2. Synchronization SUPPORTED8.5.3.3. Synchronization REQUIRED8.5.3.4. Synchronization REQUIRES_NEW8.5.3.5. Choosing between REQUIRED and REQUIRES_NEW8.5.4. Synchronization-Domain Reentrancy8.5.5. Synchronization Domain Pros and Cons
8.6. Manual Synchronization
8.6.1. The Monitor8.6.1.1. Protecting static members and methods8.6.1.2. Error handling8.6.1.3. Encapsulating Monitor8.6.1.4. Thread-safe structures8.6.1.5. Monitor and generics8.6.1.6. Synchronized methods8.6.1.7. Waiting and signaling with Monitor8.6.2. Waitable Handles8.6.2.1. Using WaitHandle8.6.2.2. WaitHandle versus Monitor8.6.3. The Mutex8.6.3.1. Using a mutex8.6.3.2. Named mutexes8.6.4. Waitable Events8.6.4.1. Manual-reset events8.6.4.2. Auto-reset events8.6.4.3. Waitable events versus monitors8.6.4.4. Thread rendezvous example8.6.5. The Semaphore8.6.6. The Interlocked8.6.7. The Reader/Writer Lock
8.7. The WorkerThread Wrapper Class
8.7.1. Launching a New Worker Thread8.7.2. Joining WorkerThread and the Thread Handle8.7.3. Terminating the Worker Thread
8.8. Synchronizing Delegates
8.9. Using .NET Multithreading Services
8.9.1. Thread-Relative Static Variables8.9.2. Thread Local Storage8.9.2.1. Using a named slot8.9.2.2. Using an unnamed slot8.9.3. The Thread Pool8.9.3.1. Configuring the thread pool8.9.4. ISynchronizeInvoke8.9.4.1. Using ISynchronizeInvoke8.9.4.2. Windows Forms and ISynchronizeInvoke8.9.4.3. Events and ISynchronizeInvoke8.9.4.4. Implementing ISynchronizeInvoke8.9.5. Windows Forms and Asynchronous Calls8.9.5.1. Web service proxy classes8.9.6. Timers8.9.6.1. System.Timers.Timer8.9.6.2. System.Threading.Timer8.9.6.3. System.Windows.Forms.Timer8.9.6.4. Choosing a timer8.9.7. Volatile Fields8.9.8. .NET and COM’s Apartments
9. Serialization and Persistence
9.1. Automatic Serialization
9.1.1. The Serializable Attribute9.1.2. Non-Serializable Members9.1.2.1. Delegates and serialization
9.2. Serialization Formatters
9.2.1. The Binary Formatter9.2.2. The SOAP Formatter9.2.3. Generic Formatters9.2.4. Serialization of Generic Type Parameters
9.3. Serialization Events
9.3.1. Applying the Event Attributes9.3.2. Serialization Events and Class Hierarchies9.3.2.1. Using the deserializing event9.3.2.2. Using the deserialized event9.3.3. Serialization and Versioning9.3.4. Type-Version Tolerance
9.4. Serialization and Streams
9.4.1. Serializing Multiple Objects
9.5. Custom Serialization
9.5.1. The ISerializable Interface9.5.2. Implementing ISerializable9.5.2.1. GenericSerializationInfo9.5.2.2. Custom serialization and IDeserializationCallback9.5.2.3. Custom serialization and serialization events9.5.3. Constraining Serialization
9.6. Serialization and Class Hierarchies
9.6.1. Custom Serialization and Base Classes9.6.2. Manual Base-Class Serialization
10. Remoting
10.1. Application Domains
10.1.1. App Domains Versus Physical Processes10.1.2. App Domains and the .NET Platform10.1.2.1. App domains and threads10.1.3. App Domains and Remoting10.1.4. The AppDomain Class10.1.4.1. The default app domain10.1.4.2. Creating objects in app domains10.1.4.3. Creating a new app domain10.1.4.4. Unwrapping remote objects10.1.5. The Host App Domain
10.2. Remote Object Types
10.2.1. Marshaling by Value10.2.2. Marshaling by Reference
10.3. Marshaling-by-Reference Activation Modes
10.3.1. Client-Activated Object10.3.2. Server-Activated Single Call10.3.2.1. Benefits of single-call objects10.3.2.2. Designing a single-call object10.3.2.3. Applying the single-call mode10.3.3. Server-Activated Singleton10.3.3.1. Using singleton objects10.3.3.2. Singleton object lifecycle10.3.4. Activation Modes and Synchronization10.3.4.1. Client-activated objects and synchronization10.3.4.2. Single-call objects and synchronization10.3.4.3. Singleton objects and synchronization
10.4. The .NET Remoting Architecture
10.4.1. Client-Side Processing10.4.2. Server-Side Processing10.4.3. Formatters10.4.4. Transport Channels10.4.5. Object Locations and Identity10.4.6. Error Handling
10.5. Building a Distributed Application
10.5.1. Programmatic Channel Registration10.5.1.1. Host channel registration10.5.1.2. Channels and formats10.5.2. Programmatic Type Registration10.5.2.1. Host type registration10.5.2.2. Client-side type registration10.5.3. Programmatic Configuration Example10.5.4. Administrative Configuration10.5.4.1. Visual Studio 2005 and configuration files10.5.5. Administrative Channel Registration10.5.5.1. Host channels registration10.5.5.2. Channels and formats10.5.6. Administrative Type Registration10.5.6.1. Host type registration10.5.6.2. Client-side type registration10.5.7. Administrative Configuration Example10.5.8. Creating Remote Objects10.5.8.1. RemotingServices.Connect()10.5.8.2. Activator.GetObject()10.5.8.3. Activator.CreateInstance()10.5.8.4. Creating remote generic objects10.5.9. Remote Callbacks10.5.9.1. Registering callback channels10.5.9.2. Remote callbacks and type filtering10.5.9.3. Remote callbacks and metadata10.5.9.4. Remote callbacks and error handling10.5.9.5. Remote callback example10.5.10. Separating the Server Code from its Metadata10.5.11. Providing a Host as a System Service10.5.11.1. Hosting with IIS
10.6. Leasing and Sponsorship
10.6.1. Lease Properties10.6.1.1. Lease manager properties10.6.1.2. Configuring global default properties10.6.2. Configuring a Lease10.6.3. Renewing a Lease10.6.4. Providing a Sponsor10.6.4.1. Sponsors and remoting10.6.4.2. Client and leases10.6.5. Leasing and Remote Activation Modes10.6.5.1. Leasing a singleton object10.6.5.2. Leasing a client-activated object10.6.6. Sponsorship Management
10.7. .NET and Location Transparency
11. Context and Interception
11.1. .NET Component Services
11.1.1. Contexts and Object Types11.1.2. Component Services Types
11.2. The .NET Context
11.2.1. Assigning Objects to Contexts11.2.2. The Call Interception Architecture11.2.2.1. Cross-context sinks11.2.2.2. Message sink types11.2.3. Same-Context Calls11.2.4. Context-Bound Objects and Remoting
11.3. Custom Component Services
11.3.1. Building a Custom Context Attribute11.3.2. Installing a Custom Message Sink11.3.2.1. Providing a server context sink11.3.2.2. Providing a client context sink11.3.2.3. Providing an envoy sink11.3.2.4. Providing an object sink11.3.2.5. Processing messages11.3.3. The Logbook Service11.3.3.1. Using the logbook11.3.3.2. The logbook service architecture11.3.3.3. Implementing the logbook11.3.4. The Transaction Management Service11.3.4.1. Transaction flow management11.3.4.2. Declarative transaction support
12. Security
12.1. The .NET Security Architecture
12.1.1. Permissions12.1.2. Permission Sets12.1.3. Security Evidence12.1.3.1. The All Code evidence12.1.3.2. The Application Directory evidence12.1.3.3. The GAC evidence12.1.3.4. The Site evidence12.1.3.5. The URL evidence12.1.3.6. The Zone evidence12.1.3.7. The Strong Name evidence12.1.3.8. The Hash evidence12.1.3.9. The Publisher evidence12.1.3.10. Selecting a security evidence12.1.4. Code Groups and Security Policies12.1.4.1. Combining policies12.1.4.2. Policy levels12.1.5. How It All Works Together
12.2. Configuring Permissions
12.2.1. .NET Default Configuration12.2.1.1. The Enterprise and User policies12.2.1.2. The Machine policy12.2.2. Custom Permission Sets12.2.3. Custom Code Groups12.2.3.1. Non-administrative permissions12.2.4. Administrating Security for ClickOnce Applications12.2.4.1. ClickOnce versioning and security12.2.4.2. Trusting ClickOnce application publishers12.2.5. Custom Security Policies12.2.5.1. Custom server-side policy12.2.5.2. Custom client-side policy12.2.6. Security Administration Utilities12.2.6.1. Resetting policies12.2.6.2. Managing policy files12.2.6.3. Adjusting security12.2.6.4. Evaluating an assembly12.2.6.5. Trusting an assembly12.2.6.6. Exporting security policies12.2.7. Security Infrastructure Benefits
12.3. Programmatic Security
12.3.1. The Permission Classes12.3.1.1. Permission demand12.3.1.2. Permission interactions12.3.2. Stack-Walk Modifiers12.3.2.1. Denying and permitting permissions12.3.2.2. Asserting permissions12.3.2.3. Asserting unmanaged code access permission12.3.3. Permission Attributes12.3.3.1. Choice actions12.3.3.2. Link-time demands12.3.3.3. Inheritance demand12.3.4. Permission Set Classes12.3.4.1. Permission set collection12.3.5. Permission Set Attributes12.3.6. Assembly-Wide Permissions
12.4. Visual Studio 2005 and Security
12.4.1. ClickOnce Permissions12.4.2. Calculating Required Permissions12.4.3. Partial-Trust Debugging12.4.4. Visual Basic 2005 and Security
12.5. Principal-Based Security
12.5.1. Declarative Role-Based Security12.5.1.1. Enabling role-based security12.5.1.2. Role-based security and authentication12.5.2. Programmatic Role-Based Security12.5.2.1. Principal and identity12.5.2.2. Verifying role membership12.5.3. Windows Security Principal12.5.4. Custom Security Principal
12.6. Addressing Other Security Issues
12.6.1. Link-Time Demand and Reflection12.6.2. Link-Time Demand and Inheritance12.6.3. Strongly Named Assemblies and Full Trust12.6.4. Unsafe Code12.6.5. Security and Remote Calls12.6.6. Serialization12.6.7. Transactions
A. Interface-Based Web Services
.NET Web Services Support
Problem Statement
Solution
Service-Side StepsClient-Side Steps
B. Unifying Windows Forms and ASP.NET Security
ASP.NET Security Infrastructure
ASP.NET Custom Authentication and Authorization
Solution Architecture
Implementing IPrincipalThe LoginControl ClassProviding input to LoginControlAuthenticating the user
The AspNetLoginControl
Implementing IUserManagerAspNetLoginControl and Code Access Security
The UserManager Web Service
The WSLoginControl
WSLoginControl and Code Access Security
The Sample Application
The LoginDialog Class
C. Reflection and Attributes
System.Type
Attributes
Using AttributesKinds of Attributes
Implementing Custom Attributes
Reflecting Custom Attributes
Generics and Reflection
Attributes and Generics
D. Generics
Generics Problem Statement
What Are Generics?
Generics Implementation
Applying Generics
Multiple Generic Types
Generic Constraints
Derivation ConstraintConstructor ConstraintClass/Struct Type Constraint
E. C# Coding Standard
Naming Conventions and Styles
Coding Practices
Project Settings and Project Structure
Framework-Specific Guidelines
MultithreadingSerializationRemotingSecurity
Colophon
Copyright

Content preview from Programming .NET Components, 2nd Edition

Component-Oriented Versus Object-Oriented Programming

If every .NET class is a component, and if classes and components share so many qualities, then what is the difference between traditional object-oriented programming and component-oriented programming? In a nutshell, object-oriented programming focuses on the relationships between classes that are combined into one large binary executable, while component-oriented programming focuses on interchangeable code modules that work independently and don’t require you to be familiar with their inner workings to use them.

Building Blocks Versus Monolithic Applications

The fundamental difference between the two methodologies is the way in which they view the final application. In the traditional object-oriented world, even though you may factor the business logic into many fine-grained classes, once those classes are compiled, the result is monolithic binary code. All the classes share the same physical deployment unit (typically an EXE), process, address space, security privileges, and so on. If multiple developers work on the same code base, they have to share source files. In such an application, a change made to one class can trigger a massive re-linking of the entire application and necessitate retesting and redeployment of all the other classes.

On the other hand, a component-oriented application comprises a collection of interacting binary application modules —that is, its components and the calls that bind them (see Figure 1-2). ...

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: 0596102070Errata Page

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Programming .NET Components, 2nd Edition

by Juval Lowy

Component-Oriented Versus Object-Oriented Programming

Building Blocks Versus Monolithic Applications

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.