Programming .Net Components

by Lowy, Juval

• ISBN13: 9780596003470
• ISBN10: 0596003471
• Format: Paperback
• Copyright: 2003-04-01
• Publisher: Oreilly & Associates Inc

Summary

The introduction of the Microsoft® .NET framework not only brings developers a powerful, cohesive toolset for the development of new Windows and Web applications -- it also replaces COM as the technology of choice for building components on Windows platforms. Components are the fundamental building blocks of .NET applications; they can both simplify and add flexibility to complex applications. Applied properly, component-oriented programming enable reuse, allow for long-term maintenance, application extensibility and scalability. "Programming .NET Components offers a complete introduction to the new Microsoft .NET component model, focusing on the aspects of .NET that make it ideal for building reusable, maintainable, and robust components. Author Juval Lvwy, a noted authority on component-oriented programming, teaches the intricacies of .NET component programming and the related system issues to application developers, along with relevant design guidelines, tips, best practices, and known pitfalls. The book is packed with helpful original utilities aimed at simplifying the programming model and increasing the developer productivity.

Author Biography

Juval Lowy is a software architect and the principal of IDesign, a .NET-focused consulting and training company. Microsoft recently named him a Software Legend for his standing within the Microsoft developer community as a leading expert on .NET design and migration

Table of Contents

Preface	xi
Introducing Component-Oriented Programming	1	(15)
Basic Terminology	2	(1)
Component-Oriented Versus Object-Oriented Programming	3	(3)
Principles of Component-Oriented Programming	6	(5)
.NET Adherence to Component Principles	11	(2)
Developing .NET Components	13	(3)
.NET Component-Oriented Programming Essentials	16	(22)
Language Independence: The CLR	16	(4)
Packaging and Deployment: Assemblies	20	(14)
Binary Compatibility	34	(4)
Interface-Based Programming	38	(21)
Separating Interface from Implementation	38	(5)
Working with Interfaces	43	(12)
Designing and Factoring Interfaces	55	(4)
Lifecycle Management	59	(16)
The Managed Heap	59	(4)
Object Finalization	63	(3)
Deterministic Finalization	66	(9)
Version Control	75	(24)
Assembly Version Number	75	(3)
Assembly Deployment Models	78	(1)
Understanding Strong Names and Shared Assemblies	79	(8)
Custom Version Policy	87	(5)
CLR Versioning	92	(7)
Events	99	(18)
Delegate-Based Events	100	(3)
Working with .NET Events	103	(14)
Asynchronous Calls	117	(29)
Requirements for an Asynchronous Mechanism	118	(1)
Revisiting Delegates	119	(2)
Asynchronous Call Programming Models	121	(14)
Asynchronous Error Handling	135	(1)
Asynchronous Events	136	(4)
Asynchronous Invocation Pitfalls	140	(3)
Synchronous Versus Asynchronous Components	143	(3)
Multithreading and Concurrency Management	146	(66)
Threads and Multithreading	146	(1)
Components and Threads	147	(1)
Working with Threads	148	(14)
Synchronizing Threads	162	(1)
Automatic Synchronization	163	(10)
Manual Synchronization	173	(23)
Using .NET Multithreading Services	196	(16)
Serialization and Persistence	212	(22)
Automatic Serialization	213	(10)
Custom Serialization	223	(4)
Serialization and Class Hierarchies	227	(7)
Remoting	234	(71)
Application Domains	234	(11)
Remote Object Types	245	(4)
Marshaling by Reference Activation Modes	249	(9)
.NET Remoting Architecture	258	(4)
Building a Distributed Application	262	(31)
Leasing and Sponsorship	293	(10)
.NET and Location Transparency	303	(2)
Context and Interception	305	(29)
.NET Component Services	305	(3)
The .NET Context	308	(8)
Custom Component Services	316	(18)
Security	334	(59)
.NET Security Architecture	335	(12)
Configuring Permissions	347	(17)
Programmatic Security	364	(17)
Principal-Based Security	381	(7)
Addressing Other Security Vulnerabilities	388	(5)
Interface-Based Web Services	393	(9)
Custom Security Principal	402	(10)
Reflection and Attributes	412	(11)
Index	423