|
 |
All orders
shipped by
airmail!
Click here for our
Shipping Policies!
| |
 | | |
"Always be nice to those younger than you, because they are the ones who will be writing about you."
- Cyril Connolly
(1903 - 1974)
| | | |
|
ZIN Product Number: 10204352
| eBay (last 12 months) | | Auctions: | | 22 | | Price Range: | | $0.02 - 0.09 | | | | Craigslist (last 12 months) | | Classifieds: | | 13 | | Price Range: | | $0.04 - 0.02 | | | | Amazon Used (last 12 months) | | Auctions: | | 87 | | Price Range: | | $0.09 - 0.02 | | | | ZooScape (last 12 months) | | Auctions: | | 0 | | Price Range: | | N/A | | | | | | Google listings (non-affiliate) | | 121 | | MSN listings (non-affiliate) | | 16 | | Yahoo listings (non-affiliate) | | 24 | | |
| | 
| | | |  | | | Product Details
 Format: Paperback, 591 pages
Publisher: Microsoft Press
ISBN: 0735614229
Release Date: Jan 1, 2002
| |  | | | From The Publisher
This title takes advanced developers and software designers under the covers of .NET to provide them with an in-depth understanding of its structure, functions, and operational components so they can create high-performance applications for .NET more easily and efficiently. Developers learn to program .NET applications while gaining a solid understanding of fundamental .NET design tenets. This title not only covers the infrastructure and architecture of .NET in-depth but also shows developers the most practical ways to apply that knowledge.
| |  | | |
 | | | | | Be the first to rate this book! Number of Reviews: 0
| | | |  | | | Acknowledgments
Introduction
PART I BASICS OF THE MICROSOFT .NET FRAMEWORK
1. The Architecture of the .NET Framework Development Platform
Compiling Source Code into Managed Modules
Combining Managed Modules into Assemblies
Loading the Common Language Runtime
Executing Your Assembly's Code
IL and Verification
The .NET Framework Class Library
The Common Type System
The Common Language Specification
Interoperability with Unmanaged Code
2. Building, Packaging, Deploying, and Administering Applications and Types
.NET Framework Deployment Goals
Building Types into a Module
Combining Modules to Form an Assembly
Adding Assemblies to a Project Using the Visual Studio .NET IDE
Using the Assembly Linker
Including Resource Files in the Assembly
Assembly Version Resource Information
Version Numbers
Culture
Simple Application Deployment (Privately Deployed Assemblies)
Simple Administrative Control (Configuration)
3. Shared Assemblies
Two Kinds of Assemblies, Two Kinds of Deployment
Giving an Assembly a Strong Name
The Global Assembly Cache
The Internal Structure of the GAC
Building an Assembly That References a Strongly Named Assembly
Strongly Named Assemblies Are Tamper-Resistant
Delayed Signing
Privately Deploying Strongly Named Assemblies
Side-by-Side Execution
How the Runtime Resolves Type References
Advanced Administrative Control (Configuration)
Publisher Policy Control
Repairing a Faulty Application
PART II WORKING WITH TYPES AND THE COMMON LANGUAGE RUNTIME
4. Type Fundamentals
All Types Are Derived from System.Object
Casting Between Types
Casting with the C# is and as Operators
Namespaces and Assemblies
5. Primitive, Reference, and Value Types
Programming Language Primitive Types
Checked and Unchecked Primitive Type Operations
Reference Types and Values Types
Boxing and Unboxing Value Types
6. Common Object Operations
Object Equality and Identity
Implementing Equals for a Reference Type Whose Base Classes Don't Override Object's Equals
Implementing Equals for a Reference Type When One or More of Its Base Classes Overrides Object's Equals
Implementing Equals for a Value Type
Summary of Implementing Equals and the ==/!= Operators
Identity
Object Hash Codes
Object Cloning
PART III DESIGNING TYPES
7. Type Members and Their Accessibility
Type Members
Accessibility Modifiers and Predefined Attributes
Type Predefined Attributes
Field Predefined Attributes
Method Predefined Attributes
8. Constants and Fields
Constants
Fields
9. Methods
Instance Constructors
Type Constructors
Operator Overload Methods
Operators and Programming Language Interoperability
Conversion Operator Methods
Passing Parameters by Reference to a Method
Passing a Variable Number of Parameters to a Method
How Virtual Methods Are Called
Virtual Method Versioning
10. Properties
Parameterless Properties
Parameterful Properties
11. Events
Designing a Type That Exposes an Event
Designing a Type That Listens for an Event
Explicitly Controlling Event Registration
Designing a Type That Defines Lots of Events
Designing the EventHandlerSet Type
PART IV ESSENTIAL TYPES
12. Working with Text
Characters
The System.String Type
Constructing Strings
Strings Are Immutable
Comparing Strings
String Interning
String Pooling
Examining a String's Characters
Other String Operations
Dynamically Constructing a String Efficiently
Constructing a StringBuilder Object
StringBuilder's Members
Obtaining a String Representation for an Object
Specific Formats and Cultures
Formatting Multiple Objects into a Single String
Providing Your Own Custom Formatter
Parsing a String to Obtain an Object
Encodings: Converting Between Characters and Bytes
Encoding/Decoding Streams of Characters and Bytes
Base-64 String Encoding and Decoding
13. Enumerated Types and Bit Flags
Enumerated Types
Bit Flags
14. Arrays
All Arrays Are Implicitly Derived from System.Array
Casting Arrays
Passing and Returning Arrays
Creating Arrays That Have a Nonzero Lower Bound
Fast Array Access
Redimensioning an Array
15. Interfaces
Interfaces and Inheritance
Designing an Application That Supports Plug-In Components
Changing Fields in a Boxed Value Type Using Interfaces
Implementing Multiple Interfaces That Have the Same Method
Explicit Interface Member Implementations
16. Custom Attributes
Using Custom Attributes
Defining Your Own Attribute
Attribute Constructor and Field/Property Data Types
Detecting the Use of a Custom Attribute
Matching Two Attribute Instances Against Each Other
Pseudo-Custom Attributes
17. Delegates
A First Look at Delegates
Using Delegates to Call Back Static Methods
Using Delegates to Call Back Instance Methods
Demystifying Delegates
Some Delegate History: System.Delegate and System.MulticastDelegate
Comparing Delegates for Equality
Delegate Chains
C#'s Support for Delegate Chains
Having More Control over Invoking a Delegate Chain
Delegates and Reflection
PART V MANAGING TYPES
18. Exceptions
The Evolution of Exception Handling
The Mechanics of Exception Handling
The try Block
The catch Block
The finally Block
What Exactly Is an Exception?
The System.Exception Class
FCL-Defined Exception Classes
Defining Your Own Exception Class
How to Use Exceptions Properly
You Can't Have Too Many finally Blocks
Don't Catch Everything
Gracefully Recovering from an Exception
Backing Out of a Partially Completed Operation When an Unrecoverable Exception Occurs
Hiding an Implementation Detail
What's Wrong with the FCL
Performance Considerations
Catch Filters
Unhandled Exceptions
Controlling What the CLR Does When an Unhandled Exception Occurs
Unhandled Exceptions and Windows Forms
Unhandled Exceptions and ASP.NET Web Forms
Unhandled Exceptions and ASP.NET XML Web Services
Exception Stack Traces
Remoting Stack Traces
Debugging Exceptions
Telling Visual Studio What Kind of Code to Debug
19. Automatic Memory Management (Garbage Collection)
Understanding the Basics of Working in a Garbage-Collected Platform
The Garbage Collection Algorithm
Finalization
What Causes Finalize Methods to Get 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
Weak References
Weak Reference Internals
Resurrection
Designing an Object Pool Using Resurrection
Generations
Programmatic Control of the Garbage Collector
Other Garbage Collector Performance Issues
Synchronization-Free Allocations
Scalable Parallel Collections
Concurrent Collections
Large Objects
Monitoring Garbage Collections
20. CLR Hosting, AppDomains, and Reflection
Metadata: The Cornerstone of the .NET Framework
CLR Hosting
AppDomains
Accessing Objects Across AppDomain Boundaries
AppDomain Events
Applications and How They Host the CLR and Manage AppDomains
"Yukon"
The Gist of Reflection
Reflecting Over an Assembly's Types
Reflecting Over an AppDomain's Assemblies
Reflecting Over a Type's Members: Binding
Explicitly Loading Assemblies
Loading Assemblies as "Data Files"
Building a Hierarchy of Exception-Derived Types
Explicitly Unloading Assemblies: Unloading an AppDomain
Obtaining a Reference to a System.Type Object
Reflecting Over a Type's Members
Creating an Instance of a Type
Calling a Type's Method
Bind Once, Invoke Multiple Times
Reflecting Over a Type's Interfaces
Reflection Performance
Index
| |  | | | Find similiar books in these subject areas:
All Topics > Computers & Internet > Microsoft > Development > .NET
All Topics > Computers & Internet > Programming > General
All Topics > Computers & Internet > General
| | | | People like you also bought:
Programming Windows with C# (Core Reference) , by Charles Petzold
NET and COM: The Complete Interoperability Guide, by Adam Nathan
How to Break Software: A Practical Guide to Testing with CD-ROM, by James A. Whittaker
Building XML Web Services for the Microsoft .NET Platform , by Scott Short
Advanced .Net Remoting, by Ingo Rammer
Building Web Solutions with ASP.NET and ADO.NET, by Dino Esposito
Inside Microsoft .NET IL Assembler, by Serge Lidin
C# and the .NET Platform, by Andrew Troelsen
Developing Applications with Visual Studio. NET, by Richard Grimes
| | | | | | Keywords
Internet programming, Microsoft net framework, Internet programming, Microsoft net framework, Microsoft.net framework, Internet programming, Computer programming, Computer Networks, Computer Bks - Languages / Programming, Computers, Programming Languages - General, Internet - General, Programming - General, Internet programming, Microsoft net framework
| |
| |
| | | |
Make $1 per sale -
Link to ZooScape.com! | |
