Question

让我来描述我的问题 - 我有一个包含非托管句柄的结构（让我们称之为Mem）。每当复制时，我都需要这个句柄来调用一个特定的方法（比如说“保留”或者保持引用计数）。

换句话说，我需要一个在内部维护引用计数的结构（我在外部也有一个机制，但需要一种方法来调用该机制）。

不幸的是，C＃不允许我以任何方式这样做。

我也不能让Mem成为一个类，因为我会将这些结构的数组传递给非托管代码，我不希望在传递它们之前逐个转换它们（只是pin和pass）。

是否有人知道可以应用于添加此行为的任何变通方法（IL Weaving等）？我相信IL不会阻止我这样做，只有C＃，对吗？

我很乐意回答有关我所拥有的框架和限制的任何问题，但我不是在寻找 - “请更改您的设计”或“不要使用C＃ “回答，非常感谢。

Answer 1

我相信IL并没有阻止我这样做，只有C＃，对吗？

是的，这就是“this”是“struct的无参数构造函数”的地方。我blogged about that前一段时间。

但是，拥有无参数构造函数不在每次复制结构时都会通知您。据我所知，基本上没办法做到这一点。当你最终得到一个“默认”值时，甚至不会在每种情况下都调用构造函数，即使它是，它肯定只是不调用复制操作。

我知道您不想听到“请改变您的设计”，但您只是在.NET中询问不存在的内容。

我建议在值类型上使用某种方法返回一个新副本，并采取适当的操作。然后，您需要确保始终在适当的时间调用该方法。除了你可以构建的任何测试之外， nothing 会阻止你出错。

Answer 2

是否有人知道可以应用于添加此行为的任何变通方法（IL Weaving等）？我相信IL不会阻止我这样做，只有C＃，对吗？

这有点正确。 C＃阻止这种情况的原因是，在许多情况下，即使在IL中定义了构造函数，也不会使用构造函数。你的情况就是其中之一 - 如果你创建了一个结构数组，那么构造函数就不会被调用，即使它们是在IL中定义的。

不幸的是，由于CLR不会调用构造函数，即使它们存在，也没有真正的解决方法。

Answer 3

编辑：我在GitHub上主持了这个答案的工作：NOpenCL library。

根据您的评论，我将以下内容确定为适用于此处讨论问题的长期行动方案。显然，问题在于在托管代码中使用OpenCL。您需要的是此API的适当互操作层。

作为一项实验，我为大部分OpenCL API编写了一个托管包装器来评估SafeHandle包装cl_mem，cl_event以及其他需要的对象的可行性致电clRelease*进行清理。最具挑战性的部分是实现像clEnqueueReadBuffer这样的方法，它们可以将这些句柄的数组作为参数。该方法的初始声明如下所示。

[DllImport(ExternDll.OpenCL)]
private static extern ErrorCode clEnqueueReadBuffer(
    CommandQueueSafeHandle commandQueue,
    BufferSafeHandle buffer,
    [MarshalAs(UnmanagedType.Bool)] bool blockingRead,
    IntPtr offset,
    IntPtr size,
    IntPtr destination,
    uint numEventsInWaitList,
    [In, MarshalAs(UnmanagedType.LPArray)] EventSafeHandle[] eventWaitList,
    out EventSafeHandle @event);

不幸的是，P / Invoke层不支持封送SafeHandle个对象的数组，所以我实现了一个名为SafeHandleArrayMarshaler的ICustomMarshaler来处理这个问题。请注意，当前实现不使用约束执行区域，因此编组期间的异步异常可能导致内存泄漏。

internal sealed class SafeHandleArrayMarshaler : ICustomMarshaler
{
    private static readonly SafeHandleArrayMarshaler Instance = new SafeHandleArrayMarshaler();

    private SafeHandleArrayMarshaler()
    {
    }

    public static ICustomMarshaler GetInstance(string cookie)
    {
        return Instance;
    }

    public void CleanUpManagedData(object ManagedObj)
    {
        throw new NotSupportedException();
    }

    public void CleanUpNativeData(IntPtr pNativeData)
    {
        if (pNativeData == IntPtr.Zero)
            return;

        GCHandle managedHandle = GCHandle.FromIntPtr(Marshal.ReadIntPtr(pNativeData, -IntPtr.Size));
        SafeHandle[] array = (SafeHandle[])managedHandle.Target;
        managedHandle.Free();

        for (int i = 0; i < array.Length; i++)
        {
            SafeHandle current = array[i];
            if (current == null)
                continue;

            if (Marshal.ReadIntPtr(pNativeData, i * IntPtr.Size) != IntPtr.Zero)
                array[i].DangerousRelease();
        }

        Marshal.FreeHGlobal(pNativeData - IntPtr.Size);
    }

    public int GetNativeDataSize()
    {
        return IntPtr.Size;
    }

    public IntPtr MarshalManagedToNative(object ManagedObj)
    {
        if (ManagedObj == null)
            return IntPtr.Zero;

        SafeHandle[] array = (SafeHandle[])ManagedObj;
        int i = 0;
        bool success = false;
        try
        {
            for (i = 0; i < array.Length; success = false, i++)
            {
                SafeHandle current = array[i];
                if (current != null && !current.IsClosed && !current.IsInvalid)
                    current.DangerousAddRef(ref success);
            }

            IntPtr result = Marshal.AllocHGlobal(array.Length * IntPtr.Size);
            Marshal.WriteIntPtr(result, 0, GCHandle.ToIntPtr(GCHandle.Alloc(array, GCHandleType.Normal)));
            for (int j = 0; j < array.Length; j++)
            {
                SafeHandle current = array[j];
                if (current == null || current.IsClosed || current.IsInvalid)
                {
                    // the memory for this element was initialized to null by AllocHGlobal
                    continue;
                }

                Marshal.WriteIntPtr(result, (j + 1) * IntPtr.Size, current.DangerousGetHandle());
            }

            return result + IntPtr.Size;
        }
        catch
        {
            int total = success ? i + 1 : i;
            for (int j = 0; j < total; j++)
            {
                SafeHandle current = array[j];
                if (current != null)
                    current.DangerousRelease();
            }

            throw;
        }
    }

    public object MarshalNativeToManaged(IntPtr pNativeData)
    {
        throw new NotSupportedException();
    }
}

这使我成功使用了以下互操作声明。

[DllImport(ExternDll.OpenCL)]
private static extern ErrorCode clEnqueueReadBuffer(
    CommandQueueSafeHandle commandQueue,
    BufferSafeHandle buffer,
    [MarshalAs(UnmanagedType.Bool)] bool blockingRead,
    IntPtr offset,
    IntPtr size,
    IntPtr destination,
    uint numEventsInWaitList,
    [In, MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(SafeHandleArrayMarshaler))] EventSafeHandle[] eventWaitList,
    out EventSafeHandle @event);

此方法声明为private，因此我可以通过一个根据OpenCL 1.2 API文档正确处理numEventsInWaitList和eventWaitList参数的方法公开它。

internal static EventSafeHandle EnqueueReadBuffer(CommandQueueSafeHandle commandQueue, BufferSafeHandle buffer, bool blocking, IntPtr offset, IntPtr size, IntPtr destination, EventSafeHandle[] eventWaitList)
{
    if (commandQueue == null)
        throw new ArgumentNullException("commandQueue");
    if (buffer == null)
        throw new ArgumentNullException("buffer");
    if (destination == IntPtr.Zero)
        throw new ArgumentNullException("destination");

    EventSafeHandle result;
    ErrorHandler.ThrowOnFailure(clEnqueueReadBuffer(commandQueue, buffer, blocking, offset, size, destination, eventWaitList != null ? (uint)eventWaitList.Length : 0, eventWaitList != null && eventWaitList.Length > 0 ? eventWaitList : null, out result));
    return result;
}

API最终在我的ContextQueue类中作为以下实例方法公开给用户代码。

public Event EnqueueReadBuffer(Buffer buffer, bool blocking, long offset, long size, IntPtr destination, params Event[] eventWaitList)
{
    EventSafeHandle[] eventHandles = null;
    if (eventWaitList != null)
        eventHandles = Array.ConvertAll(eventWaitList, @event => @event.Handle);

    EventSafeHandle handle = UnsafeNativeMethods.EnqueueReadBuffer(this.Handle, buffer.Handle, blocking, (IntPtr)offset, (IntPtr)size, destination, eventHandles);
    return new Event(handle);
}

解决方法将默认的无参数构造函数添加到结构中

3 个答案: