MSDN Magazine: COM / COM+ rss

All MSDN Magazine Topics
  • Windows With C++: Visual C++ 2010 And The Parallel Patterns Library
    Kenny Kerr - February 2009
    The Parallel Patterns Library allows you to more easily take advantage of parallelism. See what this and other Visual C++ 2010 features are in store.

  • CLR Inside Out: Best Practices For Managed And Native Code Interoperability
    Jesse Kaplan - January 2009
    There are many factors to consider when building your app with both managed and native code. Find out how to employ interop and how to choose the interop that’s right for you.

  • Basic Instincts: Inspecting COM Objects With Reflection
    Lucian Wischik - January 2009
    Reflection is useful for debugging and logging and otherwise providing the type information you need. Here you’ll see how to use reflection on COM types.

  • Test Run: Configuration Testing With Virtual Server, Part 2
    Dr. James McCaffrey and Paul Despe - December 2008
    Because Virtual Server is built upon a set of COM modules, you can automate the creation and testing of virtual machines. Here we use Windows PowerShell to run the tests.

  • CLR Inside Out: COM Connection Points
    Thottam R. Sriram - September 2007
    We create an Active Template Library (ATL) connection point server.

  • CLR Inside Out: Introduction to COM Interop
    Thottam R. Sriram - January 2007
    The CLR allows seamless interactions between Microsoft .NET applications and COM. But how, exactly? The CLR team knows.

  • Escape DLL Hell: Simplify App Deployment with ClickOnce and Registration-Free COM
    Dave Templin - April 2005
    DLL Hell that results from versioning conflicts is generally not a problem in .NET because components do not require registration, and are either totally isolated to an application or are managed in a well-defined side-by-side way with the help of the Global Assembly Cache. But if you're still using COM, wouldn't it be great if you could deploy your existing COM components using a model similar to the .NET Framework? In Windows XP, you can, and this article explains how.

  • Interop: Get Seamless .NET Exception Logging From COM Clients Without Modifying Your Code
    Matt Adamson - January 2005
    Using .NET objects from ASP can help you gain experience with the .NET Framework before migrating to ASP.NET. Your ASP pages will make use of the new .NET components through COM-callable wrappers (CCW). But how will you handle exceptions? This article fills you in.

  • App Lockdown: Defend Your Apps and Critical User Info with Defensive Coding Techniques
    Kenny Kerr - November 2004
    Whether you're storing database connection strings, user credentials, or logon info, you'll need to practice good defensive programming techniques to avoid those surprise situations in which your data is exposed. In this article, author Kenny Kerry shows you how.

  • Cryptography: Employ Strong Encryption in Your Apps with Our CryptoUtility Component
    Michael Stuart and J Sawyer - November 2004
    When storing sensitive data, you need to be able to identify threats, determine how these threats interact with each other, and how issues can combine to constitute a vulnerability that will leave your data exposed. With a good understanding of the various cryptographic algorithms, salt, hashes, ACLs, and other available techniques, you'll be in a better position to protect your critical data.

  • Virtual Server 2005: Program Customized Testing Environments Without Trashing Your Machine
    Ben Waldron - August 2004
    Efficient testing can require many different machine and server configurations but the effort needed to manage these test environments can take a toll. Microsoft Virtual Server 2005 simplifies the provisioning and management of testing environments. This article demonstrates how the extensive Virtual Server COM API can be used to create an automated application testing environment to make your testing chores a whole lot easier.

  • Data Points: Migrating from ADO to ADO.NET, Part 2
    John Papa - August 2004
    As you move forward with your use of ADO. NET, you'll need to know how to approach situations that you previously learned to handle in ADO and now have to tackle with ADO. NET. Just as n-tiered solutions developed using Visual Basic®, C++, and ASP often rely on ADO for their data access needs, Windows® Forms, Web Forms, and Web services rely on ADO.

  • Data Points: Migrating from ADO to ADO.NET
    John Papa - July 2004
    In recent years ADO has taken the lead as the preferred method for implementing data access in Windows®-based applications. Huge numbers of ADO applications are in use today and many developers are well versed in ADO development.

  • .NET Matters: XML Comments, Late-bound COM, and More
    Stephen Toub - June 2004

  • C++ Q&A: CD Burning and Device Discovery with IMAPI
    Paul DiLascia - April 2004

  • ISA Server 2004: Developing an Application Filter for Microsoft Internet Security and Acceleration Server 2004
    Yigal Edery - March 2004
    The beta version of Internet Security and Acceleration (ISA) Server 2004 is now publicly available. It includes a rich SDK with several extensibility mechanisms that allow third parties to integrate their specialized solutions on top of the ISA platform. In this article, the author explores the application filter extensibility mechanism, which enables you to add high-level application layer filtering capabilities to ISA Server and to provide rich content filtering solutions. He also highlights the new features of the ISA Server 2004 SDK, then moves on to describe how to develop a basic application filter that monitors all data going through the ISA Server, and how to integrate a filter into the ISA Server management console to create a seamless interface experience for your users.

  • Error Handling: Throwing Custom Exception Types from a Managed COM+ Server Application
    Bob DeRemer - March 2004
    Exception handling semantics in .NET are based on type, so you can create custom exceptions that have their own properties and methods. In .NET, exceptions are first-class citizens, and since they're the built-in error handling mechanism, all .NET-compliant languages must support exceptions. In addition, COM+ services are available to .NET code as Enterprise Services, so you can leverage exceptions in your Enterprise Services design.In this article the author describes custom exceptions, throwing exceptions across COM interop boundaries, and working with Enterprise Services.

  • The ASP Column: Web Services: ATL Server Versus ASP.NET
    George Shepherd - February 2004

  • Windows Shell: Create Namespace Extensions for Windows Explorer with the .NET Framework
    Dave Rensin - January 2004
    Extending the Windows shell with namespace extensions allows you to create some custom functionality for Windows Explorer. One common use is to enable Explorer to present a list of items that do not exist in one real folder, but actually reside in a number of places. The view on the folder makes it look like these items are in one place, so managing them becomes easier. This article illustrates the process of creating custom shell namespace extensions using C# and the .NET Framework. The author dispels some myths about the difficulty of writing such extensions, and shows that it is easier than it was before .NET. Along the way he outlines undocumented interfaces and describes advanced techniques for consuming them in .NET.

  • Beyond Macros: Create Word and Excel Smart Documents with C++ and XML
    Mike Kelly - December 2003
    One of the coolest new parts of Office 2003 is a programmability feature called Smart Documents, which allows developers to augment Word and Excel documents with programmable content and behavior. Typically, examples illustrating Office programmability use Visual Basic or Visual Basic .NET. In this article, the author develops a Smart Document for Excel using C++. He describes the new ISmartDocument interface and shows how to use it to manage a simple task list such as an Excel spreadsheet.

  • Authorize It: Use Role-Based Security in Your Middle Tier .NET Apps with Authorization Manager
    Keith Brown - November 2003
    Authorization Manager in Windows Server 2003 represents a significant improvement in the administration of role-based security, making it more scalable, flexible, and easier to implement. Using Authorization Manager, you can define roles and the tasks those roles can perform. You can nest roles to inherit characteristics from other roles, and you can define application groups. In addition, Authorization Manager lets you use scripts to modify permissions dynamically, and it allows you to wrap your security logic in a security policy that can be stored in Active Directory. Authorization Manager also includes an easy-to-use API for running access checks. The author discusses all of these topics and demonstrates them with a working sample.

  • The ASP Column: ATL Server Versus ASP.NET
    George Shepherd - November 2003

  • .NET Remoting: Create a Custom Marshaling Implementation Using .NET Remoting and COM Interop
    Jim Sievert - September 2003
    The .NET Framework offers several methods for customizing the presentation of native .NET and COM object types. One such technique, custom marshaling, refers to the notion of specializing object type presentations. There are times, like when a legacy COM component needs to implement a new interface or when you need to make calls across process or machine boundaries, when custom marshaling saves the day. Elements of COM Interop permit the customizing of COM types while .NET Remoting offers the developer the ability to tailor native .NET types. This article examines these techniques.

  • .NET Internals: Rewrite MSIL Code on the Fly with the .NET Framework Profiling API
    Aleksandr Mikunov - September 2003
    In this article, the author shows how to dynamically rewrite Microsoft Intermediate Language code on the fly using the Profiling API of the CLR. Unlike approaches based on Reflection.Emit, this scheme works with the existing assemblies and doesn't require the creation of proxy or dynamic assemblies. The need for IL code rewriting emerges when you want to make your changes transparent to the client and preserve the identity of classes. This technique can be used for creation of interceptors, pre- and post-processing method calls, and code instrumentation and verification.

  • Data Points: Developing Apps with the .NET Compact Framework, SQL Server CE, and Replication
    John Papa - September 2003

  • DCOM Interop: Generate Custom Managed C++ Wrappers for Easier COM Interoperation Using DCOMSuds
    Vishwas Lele - August 2003
    Now that you're writing managed code, you'll certainly want to use your existing COM components, but you can't simply call them directly. Instead, you have to wrap the COM component in a runtime-callable wrapper that acts as a proxy between the component and your managed code. While the CLR provides wrapper classes for this purpose, there will be times when you'll want custom objects to wrap your COM components. One way to get the low-level access you need to precisely control resource cleanup, pass security information, and get access to CLR features is to write your own wrapper class in managed C++. This article shows you how.

  • Web Q&A: Consuming a DataSet in ASP.NET, XML and SQL, and More
    Edited by Nancy Michell - April 2003

  • BITS: Write Auto-Updating Apps with .NET and the Background Intelligent Transfer Service API
    Jason Clark - February 2003
    Both the .NET Framework and Windows have some very interesting APIs for creating applications that are capable of updating themselves automatically over a network. There are many advantages to writing your application to update itself like Windows Update does, including convenience for your users, from easier maintenance to network administration. Automatic updates require attention to factors such as discovery, security, and file replacement. In this article, the author covers the BITS API as well as a number of features of the .NET Framework that take care of these facets of auto-updating using the same facilities that the Windows Update uses.

  • C++ and ATL: Use ATL Server Classes to Expose Your Unmanaged C++ Code as an XML Web Service
    Kirk Fertitta and Chris Sells - December 2002
    Throughout this issue, you'll read all about the promise of Web Services and how the .NET Framework enables Web Service development. Many people will also be building their Web Services atop C++ code and frameworks like ATL Server, particularly when performance is paramount. In this article, the authors show how fully functional Web Services are built using ATL Server and Visual Studio .NET. Beginning with unmanaged C++ classes, they add ATL attributes that make the code work over HTTP.

  • Web Q&A: Scripting Security
    Edited by Nancy Michell - September 2002

  • DirectShow: Core Media Technology in Windows XP Empowers You to Create Custom Audio/Video Processing Components
    Michael Blome and Mike Wasson - July 2002
    DirectShow is an API that enables Windows applications to control a wide variety of audio/video input devices including (but not limited to) DV camcorders, Web cams, DVD drives, and TV tuner cards. It provides out-of-the-box support for a variety of formats, from WAV and AVI to Windows Media. DirectShow is also extensible, enabling third parties to support their own specialized devices, formats, or processing components. This article introduces the basic concepts behind DirectShow and gives a step-by-step tutorial showing how to create your own video effect filter.

  • DirectShow: Core Media Technology in Windows XP Empowers You to Create Custom Audio/Video Processing Components
    Michael Blome and Mike Wasson - July 2002
    DirectShow is an API that enables Windows applications to control a wide variety of audio/video input devices including (but not limited to) DV camcorders, Web cams, DVD drives, and TV tuner cards. It provides out-of-the-box support for a variety of formats, from WAV and AVI to Windows Media. DirectShow is also extensible, enabling third parties to support their own specialized devices, formats, or processing components. This article introduces the basic concepts behind DirectShow and gives a step-by-step tutorial showing how to create your own video effect filter.

  • Web Q&A: XML Security Questions
    Edited by Nancy Michell - June 2002

  • Security: Unify the Role-Based Security Models for Enterprise and Application Domains with .NET
    Juval Lowy - May 2002
    Role-based security allows administrators to assign access permissions to users based on the roles they play rather than on their individual identities. These privileges can be used to control access to objects and methods, and are easier to identify and maintain than user-based security. The .NET Framework provides two role-based security models, which are exposed as two namespaces: System.Enterprise-Services and System.Security.Permissions. Presented here is a comparison of the two options and a discussion of when each is the right choice. The author also demonstrates the process involved in setting up access security and discusses role memberships.

  • COM+ 1.5: Discover Powerful Low-Level Programming in Windows XP with New COM+ APIs
    Craig Andera and Tim Ewald - April 2002
    The new version of COM+ that ships as part of Windows XP includes APIs for low-level context programming. These functions allow you to create contexts that use COM+ runtime services, independent of objects and without registering anything in the COM+ Catalog. Designed for advanced COM+ developers who understand the COM+ context model, these APIs make it easy to integrate runtime services with code in nonstandard ways. This article explains how these low-level context APIs work, discusses when you'd want to use them, and provides a .NET-based wrapper to make it simpler to use the APIs from C#.

  • SOAP: Using ATL Server to Build an Asynchronous SOAP Client in Unmanaged C++
    Pranish Kumar and Bogdan Crivat - April 2002
    SOAP opens up a new world of Web Services, letting you make function calls across a network or the Internet. But this flexibility creates new problems when your app needs to wait for calls to return from halfway around the world. What you need is an asynchronous SOAP client that takes advantage of threading to continue execution while waiting for calls over the wire. This article covers the basics of building such a client with ATL.

  • AOP: Aspect-Oriented Programming Enables Better Code Encapsulation and Reuse
    Dharma Shukla, Simon Fell, and Chris Sells - March 2002
    Aspect-oriented Programming (AOP), a paradigm invented at Xerox PARC in the 1990s, lets the developer better separate tasks that should not be inextricably tangled, such as mathematical operations and exception handling. The AOP approach has a number of benefits. First, it improves performance because the operations are more succinct. Second, it allows programmers to spend less time rewriting the same code. Overall, AOP enables better encapsulation of distinct procedures and promotes future interoperation.

  • The XML Files: Publishing and Discovering Web Services with DISCO and UDDI
    Aaron Skonnard - February 2002

  • Advanced Basics: COM+ and MTS, DCOM and MSMQ, Serialization in .NET
    Ken Spencer - February 2002

  • The XML Files: What's New in MSXML 4.0
    Aaron Skonnard - December 2001

  • Under the Hood: The .NET Profiling API and the DNProfiler Tool
    Matt Pietrek - December 2001

  • .NET CLR Profiling Services: Track Your Managed Components to Boost Application Performance
    Anastasios Kasiolas - November 2001
    The Microsoft .NET platform provides you with a rich set of services for building profilers and application monitors for applications targeting the Common Language Runtime (CLR). These services expose runtime events that occur during the execution of a .NET application. They can be used to obtain information about managed code being executed under the runtime. This article describes the .NET CLR Profiling Services and shows how to use the services to build a simple profiler that will provide hot spot information for any .NET application. The sample profiler can easily be modified to suit other profiling and monitoring needs.

  • COM+ Integration: How .NET Enterprise Services Can Help You Build Distributed Applications
    Tim Ewald - October 2001
    The .NET Common Language Runtime (CLR) is Microsoft's next-generation component technology. The CLR is a replacement for COM, but not for COM+. COM+, now called .NET Enterprise Services, is the Microsoft object runtime environment for scalable system development. This article explains how to implement and deploy COM+ configured classes using the CLR, how to access object context and call context, and the rules for managing context-relative object references. Also discussed are ways to manage precious resources such as data connections and pooled objects, and the relationship between COM+ and the new .NET remoting architecture.

  • .NET Interop: Get Ready for Microsoft .NET by Using Wrappers to Interact with COM-based Applications
    David S. Platt - August 2001
    Very soon, the development of Microsoft .NET applications will require interaction between those apps and existing COM components on both the client and the server. The .NET Framework has made provisions for this interaction by implementing various wrappers for COM objects to allow exposure of their properties and methods to .NET components. These wrappers will make it easy to make the connection between COM and .NET. After discussing wrappers, this article discusses other ways for .NET components to take part in COM+ transactions. To top off the tutorial on the interoperation of COM and .NET, the article discusses how ActiveX containers can host .NET controls, and how .NET containers can host ActiveX controls.

  • Windows XP: Make Your Components More Robust with COM+ 1.5 Innovations
    Juval Lowy - August 2001
    The next version of COM+, COM+ 1.5, offers many improvements over COM+ 1.0. A comprehensive user interface that displays more data for each application as well as complete support for legacy components make the management of existing applications easier and more efficient. Enhanced queueing support provides more flexibility for managing queued calls, and pooling and recycling means better application lifetime management. Application partitioning in COM+ 1.5 surpasses that offered in COM+ 1.0, and transaction isolation can be configured for safer transactions. COM+ 1.5 also allows you to expose any COM+ component as a Web service, as long as it meets certain criteria. This article discusses these and other new features in COM+ 1.5 that take care of much of the plumbing code, allowing developers to concentrate on business components.

  • Data Points: ADO to XML: Building a Data Access Tier with the DataManager Component
    John Papa - August 2001

  • C++ Q&A: Browser Detection Revisited, Fixing CPopupText, COM and the IServiceProvider Interface
    Paul DiLascia - June 2001

  • House of COM: Migrating Native Code to the .NET CLR
    Don Box - May 2001

  • C++ Attributes: Make COM Programming a Breeze with New Feature in Visual Studio .NET
    Richard Grimes - April 2001
    C++ attributes in Visual Studio .NET are used to generate C++ code through attribute providers. Attribute providers generate code for COM classes, and the code is injected by the C++ compiler at compile time. This has the effect of reducing the amount of code that you need to write. In addition, with C++ attributes you no longer need to maintain separate IDL and RGS files, which makes project management simpler. This article explains C++ attributes, the process used by the attribute provider to generate code, and the code that is automatically generated. It also covers how attributes affect the registration process, how attributes can be used to generate code module entry points, and how connection points can be implemented using C++ attributes. Also explained is how these features contribute to the Unified Event Model for the .NET platform.

  • SOAP Toolkit 2.0: New Definition Languages Expose Your COM Objects to SOAP Clients
    Carlos C. Tapang - April 2001
    In SOAP Toolkit 2.0, the Services Description Language (SDL) has been replaced with the Web Services Description Language (WSDL) and the Web Services Meta Language (WSML). WSDL and WSML files describe the interfaces to a service and expose COM objects to SOAP clients. This article describes a custom tool, IDL2SDL, which takes an IDL file and produces WSDL and WSML files without waiting for a DLL or TLB file to be generated. Also shown is a customized development environment in which WSDL and WSML files automatically reflect the changes to IDL files.

  • Microsoft .NET: Implement a Custom Common Language Runtime Host for Your Managed App
    Steven Pratschner - March 2001
    While most application developers may not need to write a custom host, understanding what is involved provides a great deal of insight into the architecture of the CLR. After covering how the CLR is started and loaded into a process, how to set the available configuration options, and how a host defines application domains, this article explains how to design a custom host. Important concepts include making the right decisions about the application domain boundaries for the host, configuring them correctly, loading and executing user code, and resolving references to assemblies. Setting security policy and unloading application domains as the application shuts down are also explained.

  • COM: Handle Late-bound Events within Visual Basic Using an ATL Bridge
    Carlo Randone - March 2001
    Since a Visual Basic client doesn't handle events directly from late-bound COM objects, it needs some way to capture all the events and parameters launched by any COM object server instantiated at runtime and not known at design time. This article explains how to build a bridge component that does just that. The bridge component transmits the intercepted event data back to the Visual Basic client using another supporting COM object that is capable of holding event data and attributes. The Visual Basic client receives the notification from the bridge and extracts all the information relative to the event from the supporting object.

  • COM+: Create a Compensating Resource Manager to Extend Your App's Transactional Features
    Alan Gordon - March 2001
    A Compensating Resource Manager (CRM) is any COM+ object that uses the CRM facility provided by COM+, a set of tools that make it simple to create a custom resource manager for business scenarios that require handling some non-database operation (such as generating a file) as part of a transaction. This article provides an overview of transaction processing, distributed transactions, and the two-phase commit protocol for transactions. Also covered are the implementation and configuration of a CRM.

  • C++ Q&A: Browser Detection Revisited, Toolbar Info, IUnknown with COM and MFC
    Paul DiLascia - March 2001

  • Cutting Edge: Binary Behaviors in Internet Explorer 5.5
    Dino Esposito - January 2001

  • COM+ and Windows 2000: Ten Tips and Tricks for Maximizing COM+ Performance
    David S. Platt - December 2000
    There are many tricks to getting the most out of COM+, and this article offers the author's top 10. The tips cover the importance of transaction processing, the use of the COM+ catalog, and the design of three-tier distributed systems. Writing components using the correct threading model, knowing when to use compensating transactions, and the importance of stress testing early in the process also make the list. Other indespensible suggestions emphasize the importance of recognizing where an object's state is located, choosing appropriate authentication levels for COM+ applications, using Queued Components correctly, and implementing object pooling.

  • Active Scripting APIs: Add Powerful Custom Debugging to Your Script-Hosting App
    Mike Pellegrino - December 2000
    Active Scripting is a powerful tool for adding advanced features such as macro capabilities to custom applications. This creates a need for integrated debugging services for new features added with scripting. To address this need, Microsoft has provided a set of COM interfaces for developing debugging services from within the Active Scripting framework. This article illustrates how to use the debugging services published within the Active Scripting framework to create a full-featured script debugger that can provide a multitude of debugging actions including setting breakpoints, call stack viewing, variable browsing, immediate-window viewing, thread enumeration, and application enumeration.

  • Visual Basic: Inspect COM Components Using the TypeLib Information Object Library
    Jason Fisher - December 2000
    The built-in Object Browser in Visual Basic, like other component browsers such as OLE View and XRay, is one of the more useful tools. But an even better tool would be customizable. You can build your own type library browser using the TypeLib Information Object Library (TLI), a set of COM objects designed to allow programmers to browse type libraries programmatically. This article explains type libraries and the TLI object model, and shows how to use the collections to get information about objects, leading to the creation of a custom type library explorer.

  • ActiveX and Visual Basic: Enhance the Display of Long Text Strings in a Combobox or Listbox
    John Calvert - December 2000
    The combobox and listbox controls in Visual Basic have no built-in support for displaying text strings that are too long to fit in the visible area of either control. This article describes several techniques to improve the readability of long strings in each control. The first technique uses tooltips to display a combobox or listbox item. The other techniques, which use various Windows APIs, include adding a horizontal scrollbar for a listbox and determining the necessary width of the longest string given the font attributes of the text. The required steps are described for both comboboxes and listboxes.

  • MMC: Designing TView, a System Information Viewer MMC Snap-in
    Tom Boldt - December 2000
    Windows 2000 provides remote management tools running in the Microsoft Management Console (MMC), but if you're running Windows NT 4.0 you can create your own remote management tools by writing an MMC snap-in. This article walks through the development of a distributed process management utility, TView, which is similar to Process Viewer or Task Manager. The tool consists of an MMC snap-in, a COM+ component, and a kernel-mode driver. The DCOM interface, TView's access to system processes and information, and debugging of TView are discussed in detail.

  • House of COM: Is COM Dead?
    Don Box - December 2000

  • RPC and C++: Build a Template Library for Distributed Objects Containing Multiple Interfaces
    Ajai Shankar - November 2000
    Building a C++ template library for developing distributed object-oriented applications using Remote Procedure Calls (RPC) allows the programmer to design RPC applications that are composed of components that implement multiple interfaces. This article demonstrates the use of techniques such as assembly-level thunks to build machine code on the fly, and C++ features such as templates, conversion operators, virtual destructors and virtual function tables. Along the way, familiar C++ interfaces and classes are transformed into a distributed application. The benefits of using distributed objects rather than raw remote procedures, which include writing fewer lines of code, is explained.

  • Wicked Code: Eight Lessons from the COM School of Hard Knocks
    Jeff Prosise - November 2000

  • ATL Server and Visual Studio .NET: Developing High-Performance Web Applications Gets Easier
    Shaun McAravey and Ben Hickman - October 2000
    When developing high-performance applications for the Web, developers often must choose between performance and ease of development. With ATL Server, new with Visual Studio .NET, developers get the best of both worlds. ATL Server uses a tag replacement engine written in C++, provides a simple programming model, and promotes enhanced performance and easy debugging. This article presents an overview of the ATL Server architecture, then creates a basic ATL Server project. It then goes on to explain processing SRF files, HTTP streams, forms, cookies, and header files. Managing session state is also discussed, along with file uploads and performance monitoring.

  • Propagate Error Info: Use ATL and C++ to Implement Error-Handling COM Objects
    Panos Kougiouris - October 2000
    Predefined error codes returned from HRESULT aren't always much help for debugging COM C++ code. The C++ macros provided with this article produce an XML file listing the error and its context to make debugging easier. This article begins with an overview of error handling in COM, then discusses the COM interfaces used in the macros. It explains how C++ exceptions are caught and converted to COM-compatible error information, how events are logged with the event viewer, and how context is reported in the description string of IErrorInfo. The macros handle logic errors and errors returned by an object or API.

  • Marshalling Your Data: Efficient Data Transfer Techniques Using COM and Windows 2000
    Richard Grimes - September 2000
    The way you choose to transfer data is vitally important in a distributed application. Windows 2000 provides several new features that allow you to transfer data more efficiently. Lightweight handlers allow you to write smart proxies that can cache results and perform buffered reads and writes, minimizing the number of network calls. Windows 2000 also allows you to use pipe interfaces to transfer large amounts of data efficiently through a read-ahead facility. This article illustrates several ways to improve data transfer in Windows 2000 using these new features. It also reports the results of transfer time tests and provides recommendations for transferred buffer sizes.

  • Basic Instincts: Automating COM+ Administration
    Ted Pattison - September 2000

  • Visual Programmer: Writing ActiveX Controls in Visual Basic versus Visual C++
    George Shepherd - August 2000

  • Bugslayer: A COM Symbol Engine Aids Debugging
    John Robbins - August 2000

  • Web Security: Part 2: Introducing the Web Application Manager, Client Authentication Options, and Process Isolation
    Keith Brown - July 2000
    This article, the second of two parts, continues coverage of Web security for Windows. It introduces the Web Application Manager in IIS that allows Web processes to be isolated, decreasing the security risk associated with running in a logon session. The article then picks up where Part One left off-it discusses authentication methods such as basic authentication, digest authentication, integrated Windows authentication, and anonymous logons, and the benefits and drawbacks of each.

  • SQL/MTS: Automating the Creation of COM+ Components for a Database Schema
    Aleksandr Mikunov - July 2000
    Using Microsoft Windows DNA architecture as a guideline, it's possible to create scalable multitier database applications with COM+ and Microsoft Transaction Services. In fact, you can use existing table definitions to automatically build the MTS/COM+ business logic layer and data access components for your application. This article will walk you through the development of database transactions by mapping the transactions to automatically generated MTS/COM+ components. This technique can greatly simplify the task of creating components for a large project.

  • A Simple XML-driven Tool: Monitor Your Web Site's Activity with COM and Active Scripting
    Panos Kougiouris - July 2000
    This article describes a simple Web site monitoring tool built with XML, JScript, Windows Script Host, and COM objects. Although it is not intended to replace complete Web site monitoring software products, it has many useful features that help to keep Web servers up and running. An XML configuration file specifies which Web sites to monitor and the actions to be taken if the site isn't functioning properly. In addition, the tool can be scheduled to run at any specified interval using the Windows Task Scheduler. Functions that probe the sites, log events, and send e-mail notifications are written in JScript.

  • Cutting Edge: Writing Custom OLE DB Providers Using ATL
    Dino Esposito - July 2000

  • Serving the Web: Migrating from MTS to COM+
    Ken Spencer - July 2000

  • House of COM: Using ADO to Create XML-based Recordsets
    Don Box - July 2000

  • Web Security: Putting a Secure Front End on Your COM+ Distributed Applications
    Keith Brown - June 2000
    The Internet requires that developers provide a different security model for clients than is used on a closed network. Because it would be too resource-intensive for both the client and server to prove their identity to each other, you need to look at other ways to ensure secure communications. This article covers the options, from digital certificates to public and private key encryption to Secure Sockets Layer and Web certificates. The discussion covers the installation of certificates in Microsoft Internet Information Services along with other options specific to IIS. This article was adapted from Keith Brown's Programming Windows Security (Addison-Wesley), due out in July 2000.

  • Basic Instincts: Porting Apps from MTS to COM+
    Ted Pattison - May 2000

  • Windows 2000: Asynchronous Method Calls Eliminate the Wait for COM Clients and Servers
    Jeff Prosise - April 2000
    Windows 2000 is the first version of COM to support asynchronous method calls, which permit clients to make nonblocking calls to COM objects and objects to process incoming calls without blocking the calling threads. COM clients benefit from asynchronous method calls because they can continue working while waiting for outbound calls to return. Objects benefit because they can queue incoming calls and service them from a thread pool. Our SieveClient and SieveServer sample apps demonstrate how to create and use asynchronous clients and servers in COM-based distributed applications.

  • Which Framework Should You Use?: Building ActiveX Controls with ATL and MFC
    George Shepherd - April 2000
    Currently MFC and ATL represent two frameworks targeted at different types of Windows-based development. MFC represents a simple and consistent means of creating standalone apps for Windows; ATL provides a framework to implement the boilerplate code necessary to create COM clients and servers. The two frameworks overlap in their usefulness for developing ActiveX controls. We'll take a look at both frameworks as they apply to creating ActiveX controls-highlighting strengths and weaknesses, and walking through the process of creating a control-so you can determine when you might want to use one framework or the other.

  • Serving the Web: Working with MTS, ASP, and Visual Basic
    Ken Spencer - April 2000

  • Bugslayer: Windows 2000 and LDR Messages, A COM Symbol Engine, Finding Bloated Functions, and More
    John Robbins - April 2000

  • Serving the Web: Compiling Components in Visual Basic for ASP
    Ken Spencer - March 2000

  • Basic Instincts: Porting Applications from MTS to COM+
    Ted Pattison - March 2000