상세정보

CONTENTS
Foreword = xv
Acknowledgments = xvii
Introduction = xix
PartⅠ COM+ Fundamentals
  1 Error Handing = 3
    COM+ Errors and Structured Exception Handling = 4
    The COM+ Error-Handling Model = 5
      Result Codes = 8
      Error Context = 10
    Visual Basic Environment Considerations = 12
    Visual C++ Environment Considerations = 13
    An Error-Model Integration Approach for C++ = 16
      Result Code Framework = 16
      Reporting Functions = 17
      Exception Class = 20
      Exception-Processing Macros = 27
      Usage Pattern = 29
  2 Smart Pointers = 31
    Smart Pointer Advantages = 32
    Usage Patterns = 34
    Smart Pointer Comparison = 39
    Extended Interfaces(#import) = 41
      UUID Type Binding = 41
      Exceptions = 41
      Return Values = 42
      Syntactic Properties = 45
    Smart Pointers as Parameters = 47
    Smart Pointer Pitfalls = 50
      Release = 50
      SetErrorInfo = 50
      Interoperation Leaks = 52
    Generic Programming Considerations = 53
  3 Strings = 55
    Character Encoding = 56
      American National Standards Institute (ANSI) = 56
      Double-Byte Character Set (DBCS) = 57
      Unicode = 57
    Platform Considerations = 59
    Your Project Setting = 61
    TCHAR.H = 63
    String Conversion Macros = 64
    The OLECHAR Data Type = 66
    The BSTR Data Type = 67
    BSTR Alternatives = 70
    String Templates and Classes = 72
    BSTR Wrapper Classes = 76
      Feature Comparison = 76
      Usage Pattern = 79
  4 Concurrency = 81
    Elements of Interception = 83
      Concurrency vs. Reentrancy = 83
      Interception Implementation = 83
      The Apartment = 85
      Managing STA Concurrency = 89
      The Context = 91
      The Message Filter = 98
      Interception Services = 100
    Context Neutrality = 103
      Implementation = 103
      Internal Object References = 104
      But Is It Fast? = 106
      FTM vs. TNA = 107
      It's the Object's Choice = 108
    Concurrency Design Guidelines = 109
      The Best Concurrency Is No Concurrency = 109
      Exceptions : The Case of Client Notification = 111
      Standard Synchronization Settings = 112
    Concurrency in Local Servers = 113
      Apartments in Local Servers = 113
      Local Server Pitfalls = 114
      Partial Location Transparency = 115
      Implications = 116
    Locking = 116
      Coarse-Grained Locks = 117
      Fine-Grained Locks = 130
  5 Implementation Environments = 149
    Object Glue : IDL and the Type Library = 151
    Visual C++ = 155
      COM+ Integration Approaches = 156
      Calling COM+ Objects = 158
      Implementing COM+ Objects = 162
      Event Support = 171
      Class Factories = 177
      Multi-Dual Inheritance = 179
      Special Considerations for Larger Projects = 181
    Visual Basic = 183
      Calling COM+ Objects = 183
      Implementing COM+ Objects = 185
      Event Support = 193
      Multi-Dual Inheritance = 195
    Visual J++ = 196
      Calling COM+ Objects = 197
      Implementing COM+ Objects = 202
      Event Support = 208
      Class Factories = 216
      Multi-Dual Inheritance = 217
    Script = 217
      Calling COM+ Objects = 219
      Implementing COM+ Objects = 220
      Event Support = 226
    Selecting an Implementation Environment = 228
PartⅡ Architectural Patterns and Solutions
  6 Architectural Patterns and Solutions Reuse = 235
    Reuse Through Object Orientation = 236
    Object Orientation in COM+ = 237
    Hierarchical Reuse = 239
    The Case for Isolating Interface Implementations = 240
    COM+ Solutions = 242
      Containment = 243
      Aggregation = 243
    Implementation Inheritance = 247
    Multiple Implementation Inheritance = 254
    Enhancing Source Code Reuse with C++ Templates = 263
      Parameterizing on the Derived Class Type = 264
      Parameterizing on the Base Class Type = 269
      Implementing Interfaces that Have Not Yet Been Defined = 272
  7 Streaming and Persistence = 275
    Lightweight Persistence = 277
    Persistence Solutions = 280
      Manual Data Transformation = 281
      Frameworks or Other Proprietary Solutions = 284
      Choosing a Portable Format = 287
    Type Stream Architecture = 299
      The ITypeStream Interface = 300
      The CTypeStreamlmpl Class = 303
      Type Stream Shift Operators = 315
      Encoders and Adapters = 325
      Type Stream Persistence Interface = 328
      CTypeStreamOnlStream = 334
      The C++ IOStream Adapter and Encoder = 341
      Network Data Representation = 362
      The NDR Stream = 370
      Usage Patterns = 402
  8 Marshal-by-Value = 407
    When and Why to Marshal by Value = 409
    IMarshal Examined = 414
    Na i ·· ve MBV Implementations = 417
    Reusable MBV = 421
    IMarshal Reexamined = 423
    A Solution = 425
    Marshaling Visual Basic Objects by Value = 453
    Fine-Tuning MBV = 470
    Implications = 472
  9 Reference Cycle Management = 475
    Resource Management = 476
    Abandoned Rings = 483
    Specific vs. Generic Solutions = 488
    COM+ Objects in Garbage Collection Environments = 491
      Visual Basic = 492
      Visual J++ = 497
    C++ Solution Framework = 501
    Simplifying the Model with the Universal Delegator = 512
    Reusing Split Identity from Other Languages = 515
  10 Generic Programming = 517
    The Power of Generic Programming = 518
    A Review of STL = 526
      Containers = 527
      Iterators = 529
      Generic Algorithms = 531
    Tension with Component Technology = 534
    CSB Architecture = 538
    CSB Guide = 547
      Philosophy = 547
      Collection Wrapper = 549
      Predefined Traits = 556
      Predefined Interface Method Implementations = 566
      Persistence Support = 568
      STL Adapters = 572
      Support Structures = 582
      Selecting Functionality = 585
      Project Configuration = 589
      Compiler and STL Support = 590
    CSB Internal Type Safety = 591
    Usage Patterns = 593
PartⅢ COM+ in the Enterprise
  11 Four-Tier Enterprise Application Architecture = 619
    COM+ Design Pattern Concepts = 619
      N-Tier Application Architecture = 621
      Business Objects = 623
    The Design Pattern Architecture = 626
      Presentation Services Layer = 628
      Object Services Layer = 628
      Transaction Services Layer = 629
      Data Services Layer = 630
      Simplifying Object Persistence = 630
    A COM-Based Hierarchical Object Model = 631
    From Rows and Columns to Collections and Objects = 635
      IPersistObjectStream Interface = 638
      IPersistObjectStream::CreateChildInstance = 638
      IPersistObjectStream::Load = 639
      IPersistObjectStream::Save = 639
      IPersistObjectStream::SaveCompleted = 640
      IPersistObjectStrean::Status = 640
      IObjectStream Interface = 641
      IObjectStream::Contents = 641
      IObjoctStream::Load = 642
      IObjectStream::PropertyExists = 642
      IObjectStream::PropertyIsNull = 643
      IObjectStream::ReadProperty = 643
      IObjectStream::Save = 644
      IObjectStream::WriteCollection = 644
      IObjectStream::WriteObject = 645
      IObjectStream::WriteProperty = 646
      IPersistTransStream Interface = 646
      IPersistTransStream::CreateNestedTrans = 646
      IPersistTransStream::ExecDelete = 647
      IPersistTransStream::ExecInsert = 648
      IPersistTransStream::ExecUpdate = 648
      IPersistTransStream::Save = 649
      ITransStream Interface = 650
      ITransStream::Clear = 650
      ITransStream::Contents = 650
      ITransStream::Parent = 651
      ITransStream::PropertyExists = 651
      ITransStream::PropertyIsNull = 652
      ITransStream::ReadProperty = 652
      ITransStream::Save = 653
      ITransStream::WriteCollection = 653
      ITransStream::WriteObject = 654
      ITransStream::WriteProporty = 654
      Using the Design Pattern Interfaces = 655
      Retrieving a Complex Object = 656
      Fetching Child Objects on Demand = 667
      Creating a Directory Object = 668
    Object Persistence and COM+ Transactions = 673
      Saving Changes to an Existing Object = 675
      Saving a New Object = 687
      Deleting an Object = 691
    Using the Design Pattern to Implement a Web-Based Application = 695
  12 SOAP = 697
    Why Use SOAP? = 699
    The Details of SOAP = 702
      SOAP Request = 703
      SOAP Response = 706
      SOAP Faults = 707
    SOAP Code Sample = 709
    SOAP Toolkits = 716
      Making Your SOAP Server Known = 716
      Describing Your SOAP Server = 718
      Calling the SOAP Methods = 719
    Designing SOAP Solutions = 727
      Interoperability = 729
      Performance = 730
      Support for Existing Components = 731
      Security = 731
      Drawbacks = 731
      Benefits = 731
      Toolkits = 732
  13 The MTS Revolution = 733
    A Brief History of Scalability = 734
    The Single Concurrent Client Model = 743
    Designing for Scalability = 751
      Refining a Web Example = 751
      In-Memory Alternatives = 759
      Thread Control = 767
    Transactions = 776
    Statelessness = 789
    Project Modeling for the Internet = 793
  14 Data Access = 801
    The Resource Dispenser = 803
    Data Access Technology Survey = 808
    A Crash Course in OLE DB = 813
      Transparent OLE DB Services = 816
      OLE DB Provider Service Components = 819
      OLE DB Objects = 821
      Transaction Support = 825
      Cursors = 829
      Rowset Processing = 833
    ActiveX Data Objects Briefing = 834
    Resource Pooling = 842
    C++ Data Access = 847
    Provider Specifics : Fast Loading = 859
Index = 867