Skip to main content

C# COM Interop

Introduction​

COM (Component Object Model) is a platform-independent, object-oriented system for creating binary software components that can interact with each other. Developed by Microsoft in the 1990s, COM components form the foundation of many Windows technologies and applications.

C# COM Interop (short for "COM Interoperability") is a feature that enables communication between managed .NET code and unmanaged COM components. This allows developers to:

  • Utilize existing COM components in new .NET applications
  • Access Windows system features that are only available through COM
  • Integrate with legacy systems that expose COM interfaces
  • Create COM components that can be used by older applications

In this tutorial, we'll explore how to work with COM components from C# applications, understand the underlying mechanisms, and examine practical scenarios where COM Interop proves valuable.

Understanding COM Basics​

Before diving into COM Interop, let's briefly review some COM fundamentals:

Key COM Concepts​

  1. COM Interfaces: Contracts that define methods a component implements
  2. GUIDs/CLSIDs: Globally unique identifiers for COM components
  3. COM Registration: Process of registering components in the Windows Registry
  4. Type Libraries: Metadata describing COM interfaces and components
  5. Marshaling: The process of converting data between COM and .NET environments

Working with COM Components in C#​

Importing COM Components​

To work with a COM component in C#, you first need to add a reference to it. You can do this in Visual Studio:

  1. Right-click on your project in Solution Explorer
  2. Select "Add" > "Reference"
  3. Go to the "COM" tab
  4. Select the desired component and click "OK"

This generates an Interop Assembly (a .NET assembly that wraps the COM component) that allows you to interact with the COM component using C# code.

Creating COM Object Instances​

After adding a reference to a COM component, you can create instances of COM objects:

csharp
// Creating an instance of a COM object (e.g., Excel Application)
using Excel = Microsoft.Office.Interop.Excel;

// Method 1: Using the CreateInstance method
Type excelType = Type.GetTypeFromProgID("Excel.Application");
dynamic excel1 = Activator.CreateInstance(excelType);

// Method 2: Using the COM interface directly
Excel.Application excel2 = new Excel.Application();
excel2.Visible = true;

Using COM Objects​

Once you have created a COM object, you can use its methods and properties just like any other .NET object:

csharp
using Excel = Microsoft.Office.Interop.Excel;

public void CreateExcelReport()
{
    // Create Excel application
    Excel.Application excelApp = new Excel.Application();
    excelApp.Visible = true; // Make Excel visible
    
    // Add a new workbook
    Excel.Workbook workbook = excelApp.Workbooks.Add();
    Excel.Worksheet worksheet = (Excel.Worksheet)workbook.Worksheets[1];
    
    // Add some data
    worksheet.Cells[1, 1] = "Product";
    worksheet.Cells[1, 2] = "Quantity";
    worksheet.Cells[2, 1] = "Apples";
    worksheet.Cells[2, 2] = 50;
    worksheet.Cells[3, 1] = "Oranges";
    worksheet.Cells[3, 2] = 25;
    
    // Auto-fit columns
    worksheet.Columns.AutoFit();
    
    // Save the workbook
    workbook.SaveAs("C:\\Reports\\SalesReport.xlsx");
    
    // Clean up resources (very important with COM!)
    workbook.Close();
    excelApp.Quit();
}

This code creates a simple Excel spreadsheet with some data, demonstrating how to interact with Excel through COM Interop.

Properly Releasing COM Objects​

One of the most important aspects of working with COM objects is ensuring proper cleanup. Unlike .NET objects that are automatically managed by the garbage collector, COM objects require explicit release:

csharp
using System.Runtime.InteropServices;

public void WorkWithCOMObject()
{
    Excel.Application excelApp = null;
    Excel.Workbook workbook = null;
    Excel.Worksheet worksheet = null;
    
    try
    {
        excelApp = new Excel.Application();
        workbook = excelApp.Workbooks.Add();
        worksheet = workbook.Worksheets[1];
        
        // Work with Excel...
    }
    finally
    {
        // Release COM objects in reverse order
        if (worksheet != null) Marshal.ReleaseComObject(worksheet);
        if (workbook != null) Marshal.ReleaseComObject(workbook);
        if (excelApp != null)
        {
            excelApp.Quit();
            Marshal.ReleaseComObject(excelApp);
        }
        
        // Force garbage collection to clean up any remaining COM references
        GC.Collect();
        GC.WaitForPendingFinalizers();
    }
}

Failing to properly release COM objects can lead to memory leaks and processes that don't terminate correctly.

Handling COM Errors​

COM errors often manifest differently than .NET exceptions. Here's how to handle them:

csharp
try
{
    // COM operation that might fail
    excelApp.Workbooks.Open("NonExistentFile.xlsx");
}
catch (COMException ex)
{
    // Handle COM-specific exception
    Console.WriteLine($"COM Error: {ex.ErrorCode:X} - {ex.Message}");
}
catch (Exception ex)
{
    // Handle other exceptions
    Console.WriteLine($"Error: {ex.Message}");
}

Advanced COM Interop Techniques​

Using Type Libraries and TlbImp.exe​

While Visual Studio can generate Interop assemblies automatically, you can also use the Type Library Importer (TlbImp.exe) command-line tool:

tlbimp MyComponent.tlb /out:MyComponentInterop.dll /namespace:MyNamespace

This gives you more control over how the Interop assembly is generated.

PIA (Primary Interop Assemblies)​

PIAs are officially supported Interop assemblies provided by the vendor of the COM component. For example, Microsoft provides PIAs for Office applications. Using PIAs is recommended when available as they:

  1. Are tested and supported by the component vendor
  2. Can be shared among multiple applications
  3. Often have better documentation

Dynamic COM Interop​

Sometimes, you may need to work with COM objects without having a reference at compile time. You can use the dynamic keyword for this:

csharp
// Dynamic COM interop
Type excelType = Type.GetTypeFromProgID("Excel.Application");
dynamic excel = Activator.CreateInstance(excelType);
excel.Visible = true;
dynamic workbooks = excel.Workbooks;
workbooks.Add();
dynamic sheet = excel.ActiveSheet;
sheet.Cells[1, 1].Value = "Hello from dynamic COM!";

This approach provides more flexibility but sacrifices compile-time type safety.

Real-World Application: Automating Microsoft Office​

One of the most common uses of COM Interop is automating Microsoft Office applications. Here's a more complete example of generating a Word document:

csharp
using Word = Microsoft.Office.Interop.Word;
using System.Runtime.InteropServices;

public class WordDocumentGenerator
{
    public void CreateDocumentWithTable(string title, string[][] tableData)
    {
        // COM objects to be released
        Word.Application wordApp = null;
        Word.Document document = null;
        Word.Table table = null;
        
        try
        {
            // Create Word application
            wordApp = new Word.Application();
            wordApp.Visible = true;
            
            // Create new document
            document = wordApp.Documents.Add();
            
            // Add title
            Word.Paragraph titlePara = document.Paragraphs.Add();
            titlePara.Range.Text = title;
            titlePara.Range.Font.Size = 16;
            titlePara.Range.Font.Bold = 1;
            titlePara.Range.InsertParagraphAfter();
            
            // Add a table
            int rows = tableData.Length;
            int cols = tableData[0].Length;
            table = document.Tables.Add(document.Paragraphs[document.Paragraphs.Count].Range, rows, cols);
            table.Borders.Enable = 1;
            
            // Populate table
            for (int row = 0; row < rows; row++)
            {
                for (int col = 0; col < cols; col++)
                {
                    table.Cell(row + 1, col + 1).Range.Text = tableData[row][col];
                }
            }
            
            // Format header row
            if (rows > 0)
            {
                Word.Row headerRow = table.Rows[1];
                headerRow.Range.Font.Bold = 1;
                headerRow.Shading.BackgroundPatternColor = Word.WdColor.wdColorGray15;
            }
            
            // Save document
            document.SaveAs2("C:\\Documents\\GeneratedReport.docx");
        }
        finally
        {
            // Release COM objects
            if (table != null) Marshal.ReleaseComObject(table);
            
            if (document != null)
            {
                document.Close();
                Marshal.ReleaseComObject(document);
            }
            
            if (wordApp != null)
            {
                wordApp.Quit();
                Marshal.ReleaseComObject(wordApp);
            }
            
            // Force cleanup
            GC.Collect();
            GC.WaitForPendingFinalizers();
        }
    }
}

Usage:

csharp
var generator = new WordDocumentGenerator();
var data = new string[][] {
    new string[] { "Product", "Price", "Quantity" },
    new string[] { "Widget A", "$19.99", "100" },
    new string[] { "Widget B", "$24.99", "75" },
    new string[] { "Widget C", "$14.99", "200" }
};
generator.CreateDocumentWithTable("Product Inventory Report", data);

// Output: Creates a Word document with a title and formatted table

Creating COM-Callable Components​

In addition to consuming COM components, you can also expose .NET classes as COM components for use by COM clients:

  1. Add COM-visible attributes to your class:
csharp
using System.Runtime.InteropServices;

[Guid("EAA4976A-45C3-4BC5-BC0B-E474F4C3C83F")]
[ComVisible(true)]
public interface IMathLibrary
{
    double Add(double a, double b);
    double Subtract(double a, double b);
    double Multiply(double a, double b);
    double Divide(double a, double b);
}

[Guid("7D11B0D0-C11E-4E5F-8C83-C3E89C3F6E1D")]
[ComVisible(true)]
[ClassInterface(ClassInterfaceType.None)]
[ProgId("CSharpCom.MathLibrary")]
public class MathLibrary : IMathLibrary
{
    public double Add(double a, double b) => a + b;
    public double Subtract(double a, double b) => a - b;
    public double Multiply(double a, double b) => a * b;
    
    public double Divide(double a, double b)
    {
        if (b == 0)
            throw new ArgumentException("Divisor cannot be zero");
        return a / b;
    }
}

  1. Configure project settings to register for COM interop:

    • Open project properties
    • Go to "Build" tab
    • Check "Register for COM interop"

  2. Build your project, and the assembly will be registered as a COM component.

Performance Considerations​

When working with COM Interop, keep these performance tips in mind:

  1. Minimize Crossing Boundary: Each call between managed and unmanaged code incurs overhead. Batch operations when possible.

  2. Release COM Objects Promptly: Properly release COM objects when done to avoid memory leaks.

  3. Use Early Binding: When possible, use early binding (reference at compile time) instead of late binding (dynamic) for better performance.

  4. Cache COM Objects: If you need to make multiple calls to the same COM object, cache it rather than creating new instances.

csharp
// Inefficient - crosses COM boundary multiple times
worksheet.Cells[1, 1].Value = "Product";
worksheet.Cells[1, 2].Value = "Price";
worksheet.Cells[1, 3].Value = "Quantity";

// More efficient - uses a range object to minimize boundary crossing
var range = worksheet.Range["A1:C1"];
object[,] values = new object[1, 3] { { "Product", "Price", "Quantity" } };
range.Value = values;

Common Issues and Solutions​

Issue: RCW (Runtime Callable Wrapper) not releasing properly​

Solution: Use Marshal.ReleaseComObject() and call GC.Collect() to force cleanup.

Issue: COM component not found​

Solution: Ensure the component is properly registered on the system using regsvr32.exe for DLLs or checking registry entries.

Issue: COM exceptions with cryptic error codes​

Solution: Use Marshal.GetExceptionForHR() to get more information about HRESULT error codes.

Issue: Type mismatch errors​

Solution: Ensure proper data type conversions between .NET and COM types, particularly with arrays and strings.

Summary​

C# COM Interop provides a bridge between the .NET world and legacy COM components, enabling developers to leverage existing code and access platform-specific functionality. Key points to remember:

  • COM Interop allows C# applications to work with COM components and vice versa
  • The process involves creating wrapper classes that handle marshaling between managed and unmanaged code
  • Proper resource management is critical when working with COM objects
  • COM Interop is commonly used for Office automation, accessing Windows system features, and integrating with legacy systems
  • Creating COM-callable components allows exposing .NET functionality to COM clients

By understanding COM Interop, you can integrate diverse technologies in your applications and extend the life of valuable legacy code.

Additional Resources​

Exercises​

  1. Create a simple Excel spreadsheet with data and formatting using COM Interop.
  2. Build a class that exposes .NET functionality as a COM component.
  3. Create a utility that can convert Word documents to PDF using COM Interop.
  4. Compare the performance of direct COM calls versus batched operations for a large dataset.
  5. Research how to deploy an application that uses COM Interop to machines that might not have the COM component registered.

If you spot any mistakes on this website, please let me know at [email protected]. I’d greatly appreciate your feedback! :)