In versions 1.0 and 1.1 of the .NET Framework, there was no way to pass a Variant of type VT_VARIANT | VT_BYREF to native code through PInvoke or COM Interop.  The Interop layer would extract the actual type being passed to native and use the matching Variant type to create the marshaled Variant e.g. a string would always be passed as a VT_BSTR, an Int32 would always be passed as a VT_I4 and so on.  During implementation of version 2.0, we (the CLR Interop team) received quite a few customer requests asking us to add this support.

   One use of passing VT_VARIANT | VT_BYREF Variants is that the actual type of the Variant can be changed by the callee e.g. a Variant of type (VT_VARIANT | VT_BYREF)=>VT_DATE passed in such a manner can be changed to any valid Variant type on the native side i.e. (VT_VARIANT | VT_BYREF)=>VT_*.  Supporting this scenario is especially important for MFC COM objects since the MFC IDispatch implementation explicitly checks for (VT_VARIANT | VT_BYREF) flags on every parameter declared as a VARIANT*.

   So in version 2.0 and SP1 of version 1.1 the Interop team added a VariantWrapper class (to the System.Runtime.InteropServices namespace) to provide support for this scenario.  Below are code snippets for the various usage scenarios---(1) latebinding to COM through reflection in C#, (2) implicit latebinding to COM in VB.NET and (3) calling a disponly COM interface in C# (the actual call made by the runtime is an IDispatch call):

(1) Late binding in C#

// calling COMType::ChangeVariantTypeToBSTR(VARIANT* pv);
Object[] params = new Object[1];
params[0] = new VariantWrapper(4);
ParameterModifier[] pms = new ParameterModifier[1];
ParameterModifier pm = new ParameterModifier(1);
pm[0] = true; // pass the 1st argument by reference
pms[0] = pm; // add pm to the array of modifiers
// (VT_VARIANT | VT_BYREF)=>VT_I4 passed to COM method
COMType.InvokeMember("ChangeVariantTypeToBSTR",...,params,pms,...);
// COM method changes the type from VT_I4 to VT_BSTR so after the call params[0] is a string
String retString = params[0];

Note that the ParameterModifier class is used to specify ByRef semantics for any parameter of type VariantWrapper (passed latebound in this manner).

(2) VB.NET implicit late binding 
' calling COMType::ChangeVariantTypeToBSTR(VARIANT* pv);
Object o = new VariantWrapper(4) 
' (VT_VARIANT | VT_BYREF)=>VT_I4 passed to COM method
COMType.ChangeVariantTypeToBSTR(o)
' COM method changes the type from VT_I4 to VT_BSTR so after the call 'o' is a string
String retString = o

Note that VB.NET adds ByRef semantics automatically for every implicit late binding call. Also note that ''o' is declared as an Object and not a VariantWrapper since the runtime Interop layer will not re-wrap the passed in parameter on the return trip from native. After the call, 'o' is whatever type the Variant was changed to on the native side (or the original type that was wrapped if no change is made on the native side).

(3) Calling COM method on a Disponly interface with early binding syntax in C# 
// calling COMType::ChangeVariantTypeToBSTR(VARIANT* pv);
Object o = new VariantWrapper(4); 
// (VT_VARIANT | VT_BYREF)=>VT_I4 passed to COM method
COMType.ChangeVariantTypeToBSTR(ref o);
// COM method changes the type from VT_I4 to VT_BSTR so after the call 'o' is a string
String retString = o'

Note that in this scenario the ref keyword is required to specify ByRef semantics for any parameter of type VariantWrapper.

The VariantWrapper class does have its limitations with respect to its use in Interop:

Early binding is not supported.  An ArgumentException is thrown if an attempt is made to use the class in earlybound calls to native code.
Nesting of VariantWrappers is not supported i.e. VariantWrappers cannot wrap other VariantWrappers.  Note that wrapping other wrappers in VariantWrappers is allowed e.g. VariantWrapper(DispatchWrapper(someClass)).
VariantWrapper structure fields are not supported.
Arrays of VariantWrappers are not allowed.  An ArgumentException is thrown if an attempt is made to use a VariantWrapper array in calls to native code.