По умолчанию объекты .NET имеют свободную многопоточность. Если они маршалируются в другой поток через COM, они всегда маршалируются сами себе, независимо от того, был ли поток-создатель STA или нет, и независимо от их значения реестра ThreadingModel
. Я подозреваю, что они объединяют Free Threaded Marshaler (более подробную информацию о потоках COM можно найти здесь).
Я хочу, чтобы мой COM-объект .NET использовал стандартный прокси-маршаллер COM при маршалировании в другой поток. Проблема:
using System;
using System.Runtime.InteropServices;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Threading;
namespace ConsoleApplication
{
class Program
{
static void Main(string[] args)
{
var apt1 = new WpfApartment();
var apt2 = new WpfApartment();
apt1.Invoke(() =>
{
var comObj = new ComObject();
comObj.Test();
IntPtr pStm;
NativeMethods.CoMarshalInterThreadInterfaceInStream(NativeMethods.IID_IUnknown, comObj, out pStm);
apt2.Invoke(() =>
{
object unk;
NativeMethods.CoGetInterfaceAndReleaseStream(pStm, NativeMethods.IID_IUnknown, out unk);
Console.WriteLine(new { equal = Object.ReferenceEquals(comObj, unk) });
var marshaledComObj = (IComObject)unk;
marshaledComObj.Test();
});
});
Console.ReadLine();
}
}
// ComObject
[ComVisible(true)]
[Guid("00020400-0000-0000-C000-000000000046")] // IID_IDispatch
[InterfaceType(ComInterfaceType.InterfaceIsIDispatch)]
public interface IComObject
{
void Test();
}
[ComVisible(true)]
[ClassInterface(ClassInterfaceType.None)]
[ComDefaultInterface(typeof(IComObject))]
public class ComObject : IComObject
{
// IComObject methods
public void Test()
{
Console.WriteLine(new { Environment.CurrentManagedThreadId });
}
}
// WpfApartment - a WPF Dispatcher Thread
internal class WpfApartment : IDisposable
{
Thread _thread; // the STA thread
public System.Threading.Tasks.TaskScheduler TaskScheduler { get; private set; }
public WpfApartment()
{
var tcs = new TaskCompletionSource<System.Threading.Tasks.TaskScheduler>();
// start the STA thread with WPF Dispatcher
_thread = new Thread(_ =>
{
NativeMethods.OleInitialize(IntPtr.Zero);
try
{
// post a callback to get the TaskScheduler
Dispatcher.CurrentDispatcher.InvokeAsync(
() => tcs.SetResult(System.Threading.Tasks.TaskScheduler.FromCurrentSynchronizationContext()),
DispatcherPriority.ApplicationIdle);
// run the WPF Dispatcher message loop
Dispatcher.Run();
}
finally
{
NativeMethods.OleUninitialize();
}
});
_thread.SetApartmentState(ApartmentState.STA);
_thread.IsBackground = true;
_thread.Start();
this.TaskScheduler = tcs.Task.Result;
}
// shutdown the STA thread
public void Dispose()
{
if (_thread != null && _thread.IsAlive)
{
InvokeAsync(() => System.Windows.Threading.Dispatcher.ExitAllFrames());
_thread.Join();
_thread = null;
}
}
// Task.Factory.StartNew wrappers
public Task InvokeAsync(Action action)
{
return Task.Factory.StartNew(action,
CancellationToken.None, TaskCreationOptions.None, this.TaskScheduler);
}
public void Invoke(Action action)
{
InvokeAsync(action).Wait();
}
}
public static class NativeMethods
{
public static readonly Guid IID_IUnknown = new Guid("00000000-0000-0000-C000-000000000046");
public static readonly Guid IID_IDispatch = new Guid("00020400-0000-0000-C000-000000000046");
[DllImport("ole32.dll", PreserveSig = false)]
public static extern void CoMarshalInterThreadInterfaceInStream(
[In, MarshalAs(UnmanagedType.LPStruct)] Guid riid,
[MarshalAs(UnmanagedType.IUnknown)] object pUnk,
out IntPtr ppStm);
[DllImport("ole32.dll", PreserveSig = false)]
public static extern void CoGetInterfaceAndReleaseStream(
IntPtr pStm,
[In, MarshalAs(UnmanagedType.LPStruct)] Guid riid,
[MarshalAs(UnmanagedType.IUnknown)] out object ppv);
[DllImport("ole32.dll", PreserveSig = false)]
public static extern void OleInitialize(IntPtr pvReserved);
[DllImport("ole32.dll", PreserveSig = true)]
public static extern void OleUninitialize();
}
}
Вывод:
{ CurrentManagedThreadId = 11 } { equal = True } { CurrentManagedThreadId = 12 }
Обратите внимание, что я использую _3 _ / _ 4_ для маршалинга ComObject
от одного потока STA к другому. Я хочу, чтобы оба вызова Test()
вызывались в одном и том же исходном потоке, например 11
, как это было бы в случае с типичным COM-объектом STA, реализованным на C ++.
Одно из возможных решений - отключить интерфейс IMarshal
на объекте .NET COM:
[ComVisible(true)]
[ClassInterface(ClassInterfaceType.None)]
[ComDefaultInterface(typeof(IComObject))]
public class ComObject : IComObject, ICustomQueryInterface
{
// IComObject methods
public void Test()
{
Console.WriteLine(new { Environment.CurrentManagedThreadId });
}
public static readonly Guid IID_IMarshal = new Guid("00000003-0000-0000-C000-000000000046");
public CustomQueryInterfaceResult GetInterface(ref Guid iid, out IntPtr ppv)
{
ppv = IntPtr.Zero;
if (iid == IID_IMarshal)
{
return CustomQueryInterfaceResult.Failed;
}
return CustomQueryInterfaceResult.NotHandled;
}
}
Вывод (по желанию):
{ CurrentManagedThreadId = 11 } { equal = False } { CurrentManagedThreadId = 11 }
Это работает, но похоже на взлом, связанный с конкретной реализацией. Есть ли более приличный способ сделать это, например, какой-то специальный атрибут взаимодействия, который я мог упустить? Обратите внимание, что в реальной жизни ComObject
используется (и маршалируется) устаревшим неуправляемым приложением.
await WpfApartment.InvokeAsync(()=>DoSomething())
, для маршалинга вызовов между потоками STA. - person noseratio   schedule 20.02.2015ComRegisterFunctionAttribute
для регистрации объекта какThreadingModel=Apartment
. Тем не менее, как я уже упоминал выше, это не меняет описанного мною маршалинга. Неуправляемый клиент вызываетCoMarshalInterThreadInterfaceInStream
в одном потоке STA, затемCoGetInterfaceAndReleaseStream
в другом потоке STA и получает тот же объект, не прокси. Это потому, что любая .NET CCW реализуетIMarshal
, а имеет свободную многопоточность, независимо от ееThreadingModel
в реестре. Не верьте мне на слово, попробуйте сами. - person noseratio   schedule 20.02.2015IComObject
s какIDispatch
? - person acelent   schedule 23.02.2015IDispatch
безRegAsm
. COM используетIDispatch::Invoke
, а .NET имеет достаточно метаданных, чтобы сделать этиIDispatch::Invoke
вызовы жестко типизированными. - person noseratio   schedule 23.02.2015