COMQC_E_NO_IPERSISTSTREAM Fix: Marshal Error 0X80110603

You're running a Windows app—maybe a custom tool you wrote, maybe a legacy VB6 component—and suddenly you see COMQC_E_NO_IPERSISTSTREAM (0X80110603) with the message "Unable to marshal an interface that does not support IPersistStream." This often happens when you're trying to pass an object across process or apartment boundaries—for example, from a background thread to a UI thread, or between two COM components in different processes. The trigger is usually a call to CoMarshalInterface or a COM method that internally does marshaling, like IMarshal::MarshalInterface, on an object that doesn't implement IPersistStream.

Root Cause in Plain English

COM needs a way to serialize an object's state when it crosses boundaries. It does this through the IPersistStream interface. If your object doesn't implement that interface, COM can't package it up and send it over. The error is COM telling you, "Hey, I can't move this object—it doesn't know how to save itself."

The fix isn't to change the error code—it's to either make your object support IPersistStream or switch to a marshaling method that doesn't require it. Most of the time, you don't really need to marshal the object at all. You just need to pass data or a reference that survives the boundary.

How to Fix It (Numbered Steps)

1. Identify the object being marshaled. Look at your code where the error occurs. If it's a custom class, note it. If it's a third-party object, check its documentation. The error message usually doesn't name the object, so add logging around your marshaling calls to see which one fails.
2. Check if the object implements IPersistStream. In C++, call QueryInterface for IID_IPersistStream. In C#, try casting the object to System.Runtime.InteropServices.ComTypes.IPersistStream. If the cast returns null, that's your problem.
3. If it doesn't, you have two options:
   • Implement IPersistStream on your class. This is the proper fix if you control the class. You'll need to implement GetClassID, IsDirty, Load, Save, GetSizeMax. In C++, use ATL's IPersistStreamImpl to simplify. In C#, you can use the .NET IPersistStream interface and Marshal class.
   • Skip marshaling entirely. If you're just passing a reference for read-only use, consider using a weak reference or a shared data structure like a database or a file. This avoids the overhead and the error.
4. For the common case where you're passing an object within the same process but across threads, switch to a delegate or a callback. Instead of marshaling the object, pass a delegate that runs on the target thread. In C#, use Control.Invoke or Dispatcher.BeginInvoke. In C++, use PostMessage with a custom message.
5. If you must marshal and you can't modify the class, create a wrapper class that implements IPersistStream and contains a reference to the original object. The wrapper's Save method can serialize the original object's properties manually.

What to Check If It Still Fails

First, verify that your changes actually took effect. Rebuild your project fully—sometimes incremental builds miss the interface changes. Second, check that you're not accidentally calling CoMarshalInterface on a proxy object that already failed. Third, look at the registry: if you're using a COM server, confirm the IPSFactoryBuffer registration is correct. Finally, test in a clean environment—disable antivirus or firewall that might interfere with COM marshaling.

The real fix here is almost always to stop trying to marshal the object. Pass the data, not the object. If you absolutely need the object, implement IPersistStream correctly. I've seen teams spend days on this error when the answer was to use a simple struct instead of a full COM object.