Blunder Dome Sighting  

Hangout for experimental confirmation and demonstration of software, computing, and networking. The exercises don't always work out. The professor is a bumbler and the laboratory assistant is a skanky dufus.

Click for Blog Feed
Blog Feed

Recent Items
A Conceptual Architect Am I?
Cybersmith: Attributions for Code You Use
DMware: ODMA's Dark Matter
Cybersmith: No-friction Bits and Pieces
VC++ Novice: Is Native C++ a Dead Language?
nfoWorks: What Are those Harmony Principles, Agai...
nfoWorks: Tracking OOXML DIS 29500 into the Blue
nfoWorks: The ISO/IEC Harmonization Opportunity
nfoWorks: In Search of Initiative
nfoWorks: The Harmony Get-Ready

This page is powered by Blogger. Isn't yours?

Locations of visitors to this site
visits to Orcmid's Lair pages

The nfoCentrale Blog Conclave
Millennia Antica: The Kiln Sitter's Diary
nfoWorks: Pursuing Harmony
Numbering Peano
Orcmid's Lair
Orcmid's Live Hideout
Prof. von Clueless in the Blunder Dome
Spanner Wingnut's Muddleware Lab (experimental)

nfoCentrale Associated Sites
DMA: The Document Management Alliance
DMware: Document Management Interoperability Exchange
Millennia Antica Pottery
The Miser Project
nfoCentrale: the Anchor Site
nfoWare: Information Processing Technology
nfoWorks: Tools for Document Interoperability
NuovoDoc: Design for Document System Interoperability
ODMA Interoperability Exchange
Orcmid's Lair
TROST: Open-System Trustworthiness



Cybersmith: Resources for .NET Interop

Exploiting Interoperability Opportunities

There are a variety of techniques for integration and interoperability between execution models (POSIX, Win32, Java, .NET, etc.) and their platforms (via linking, inter-process communication, remoting, Web Services,  Ajax, etc.).   Interoperability arrangements can be extremely valuable in the reuse and repurposing of existing software and systems without requiring expensive, time-consuming, and just-plain-risky re-implementation. 

The well-prepared cybersmith will want to avoid fragile, over-complex approaches and deliver something that is clear-cut, durable, and sufficient to the task.  Seasoned cybersmiths will also anticipate future prospects for interoperability in their architectural approaches.  That starts when thinking critically about immediate interoperability benefits in the software-development lifecycle: fitting into test harnesses, offering interface contracts, and re-integrating in cycles of build, integration, system test, and deployment.  Anticipating interoperability between versions of the same system and its data is master-class cybersmithing.

Interoperability is a complex situation and not for the faint-of-heart.  Unfortunately, it usually comes up under rush conditions.  When I notice resources that may ease the shock and assist in realistic assessment of what's required for a particular kind of interoperability, I'll start a list like this first one.

.NET Interop Resources

Here's an alphabetical collection of resources for .NET interoperability that I originally compiled for an Interoperability Forum.  That's a better place to submit additions than in the comments on this post, although I will notice them either way.  This list will be updated from time to time.  Eventually, it will link to a web location where more depth can be provided.

  • All About Interop: Connecting .NET to just about anything else.  (web log)
    The blog of Microsoft's Dino Chiesa covers general interoperability involving .NET.  Although the blog tends to feature interoperability via communication arrangements, such as Web Services, there are discussions of topics related to linking and run-time interoperability.  Click the "Interoperability" tag on any page to zero in on interoperability-focused posts.  (Thanks to Enzo De Lorenzi.)
  • Tim Mallalieu and Jeromy Carriere: Enterprise Interoperability: .NET and J2EE (via Warren DuBois).  article, Building Distributed Applications, Enterprise Architecture Patterns & Practices, MSDN Online, January 2004. 
    Although slightly dated, this article provides an overview and many links for those looking to address the different opportunities and trade-offs.
  • Gotchas with .NET (web article, via Silvain Trudel)
    Jeff Cope addresses some specific .NET COM Interop considerations in the context of integration with PDMWorks Enterprise.  Although some good understanding of Interop is required to apply these tips in other situations, they may be useful to review.

  • Jesús Rodríguez: Interoperability with Message Exchange Patterns Created Using BEA Weblog 8.1.3 (via Messages and Services).  article, Building Distributed Applications, Enterprise Architecture Patterns & Practices, MSDN Online, January 2005.
       Although grounded in a very specific case, the narration of the various considerations may be useful in considering other cases of web services interoperability.  There are additional cases listed at the Messages and Services page.  Here the .NET operation is as a client or server process of a web-service exchange.

  • Interoperating with Unmanaged Code.  online article, .NET Framework Developers Guide, MSDN Online (undated).
    An overview from the .NET perspective, dealing with pre-C++/CLI cases.  This additional view may help form an understanding of what is involved.  This assumes some knowledge of unmanaged code technologies (Win32, COM, ActiveX, etc.)

  • Thottam R. Sriram: Introduction to COM Interop.  article, CLR Inside Out column, MSDN Magazine, January 2007.
       This introduction takes a leisurely approach through the basics of interoperability between unmanaged COM code and managed .NET code. In addition to demonstration of all cases, there is discussion of debugging, with additional references for further resources.

  • Managed, Native, and COM Interop Team on CodePlex (project web folder, via Darren Stokes)
    The main project of this effort is the P/Invoke Interop Assistant that can be used to see how C/C++ calls are translated to .NET calls, and how .NET entries can be accessed from C/C++ calls.  There are help files and guidance on how parameters are marshalled between the Win32 native and the .NET environments.  This is an useful way to understand Interop from execution environments that have C/C++ native calling and entry-point provisions.

  • Yi Zhang and Xiaoying Guo: Marshaling between Managed and Unmanaged Code.  article, CLR Inside Out column, MSDN Magazine, January 2008.
       This article provides an extensive analysis of the ways that calls and datatypes are in either direction between managed and unmanged code.  An early version of the P/Invoke Interop Assistant is provided along with the downloadable examples.

  • MSDN Magazine (online issues).
    The on-line issues extend back to March, 2000.  The magazine articles can be found by issue, by column, and by topic (all in the sub-menu at the top of the home page).  All code can be downloaded and individual issues can be downloaded in HTML Help (.chm) format. 

  • MSDN Online (web site).
    The on-line vresion of the Microsoft Developers Network provides extensive materials including the online issues of MSDN Magazine.  The recently-updated site design provides easy search for interop-related materials, with opportunity for browsing and narrowing the search to more-specific material of interest.

  • Native and .NET Interoperability.  (online article) MSDN Library.
    This MSDN section deals with the ways that .NET and Native code can be mixed using the C++/CLI extensions of VC++ 2005 and later.  It may shed more light on efforts to mix code as part of an integration across different development and runtime environments.

  • Adam Nathan: .NET and COM: The Complete Interoperability Guide.  Sams Publishing (Indianapolis, IN: 2002), ISBN 0-672-32170-X pbk (2 volumes). 
    Although this book was published at the time that .NET 1.0 shipped, it is probably the most comprehensive treatment of the topic that will ever be found, with substantial code examples and description of the various tools that are useful in a great variety of combinations.  Although the C++/CLI extensions were not available, and .NET is now richer, there are still topics here that are found nowhere else.  This resource is also indicated if one is considering using COM as a way to access .NET from other native-programming environments.  I also find it valuable in describing how to design for interoperability at either starting point for an interoperability solution.

  • .NET Gotchas (book, via Jeff Cope)
    This 2005 O'Reilly book by Venkat Subramaniam lists a number of elements to watch out for in using COM Interop and also in deploying .NET Assemblies that use COM objects underneath.

  • Stephen R. G. Fraser: Pro Visual C++/CLI and the .NET 2.0 Platform.  Apress (Berkeley, CA: 2006), ISBN 1-59059-640-4
    This is a thick and somewhat murky book.  It tends to look at VC++ entirely from the C++/CLI language that the /clr option switches to.  It does not connect the dots to native C++ that well.  The pacing is leisurely enough that patient testing of the material by creating and varying the examples and samples may be useful.  There are only two chapters focused on the interactions with unmanaged code.

  • The ServerSide Interoperability Blog. (web log)
    Although silent since December 2007, this blog is directed to cross-platform interoperability.  The archives have useful content.  The sponsoring site tends to look at interoperability and integration from the Java side.  Sponsoring site starts on the .NET side, with material on "language interop."  These sites provide registration for e-mail notices of information and announcements, including ones related to interoperability.
  • VST.NET (via Marc's Blog Cabin).  open-source project folder, CodePlex (LGPL 2.1 license).
    This is an early version (0.2 as of 2008-06-21) of a developing worked example of a framework for starting from the C Language API that VST modules must offer, down through implementation of the module via .NET (exploiting Visual C++/CLI for the bridge, C# for the managed-code components called from the bridge).  Virtual Studio Technology (VST) is an audio plug-in model defined by Steinberg Media Technologies and used to add audio processors and instruments to popular audio creation software.  VST.NET is a real-world example of taking a specialized interface and allowing creation of VSTs using .NET via interop through C++/CLI.  VST is a de facto standard for interoperable plug-ins of these fixtures.  There is additional information on author Marc Shapiro's Jacobi's blog.  The framework model may be more than what's needed in a particular interop situation.  The modularization and use of a managed-code loader are instructive either way.

On the Interoperability Forums and the MSDN Forums (new ones and still old ones), requests for assistance with forms of .NET interop tend to arrive in many different places.  Putting this list on the Interoperability Forums was intended to assist those who landed there looking for guidance.  That is generally not the place where direct support is available, so I am reluctant to refer other requests there.  This post is here as an alternative that I am more comfortable with as a known place that I can link to in responding to requests for .NET interop information in other places.  When I find specific resources in applicable forums and web sites, I will lead to those from here too.

[update 2008-08-05T14:55Z Corrected Marc Jacobi's name as the author of VST.NET.  I am correcting this on the Interoperability Forum also.] 


I'm the author of VST.NET and my name is Marc Jacobi, not Marc Shapiro!

Thanks for referencing my little project.

Marc Jacobi

I thought I'd let you know that VST.NET is currently at version 0.6.

This release not only contains the Plugin side of VST but there is also Interop support for the Host. So it is now possible to create a managed VST Host (hosting unmanaged plugins). VST.NET 0.6 ships with a code sample of a simple Host application demonstrating the usage of the Managed Host Interop classes.

Marc Jacobi

Construction Structure (Hard Hat Area) You are navigating Orcmid's Lair.

template created 2004-06-17-20:01 -0700 (pdt) by orcmid
$$Author: Orcmid $
$$Date: 10-04-30 22:33 $
$$Revision: 21 $