通过单个功能“使用”多个IDisposable

Question

I have a method that returns a NativeList<> of structs AStruct , where NativeList<> is a wrapper over unmanaged memory that implements IDisposable . AStruct contains another pointer backed by a NativeList<float> also created in the same method, so:

private unsafe NativeList<AStruct> GetAStructs()
{
    var floatList = new NativeList<float>();
    floatList.Add(0.0f);

    var list = new NativeList<AStruct>();

    AStruct a1 = new AStruct();
    a1.floats = (float*)floatList.Data;
    list.Add(a1);

    // ...

    return list;
}

This is a problem because now floatList is not referenced anymore after calling GetAStructs() . So I've changed the method signature to include an out parameter.

private unsafe NativeList<AStruct> GetAStructs(out IDisposable toDispose)
{
    // ...

    toDispose = floatList;
    return list;
}

And I'm calling it like this

using (NativeList<AStruct> disposableList = GetAStructs(out IDisposable toDispose))
using (toDispose)
{
    callNativeFunction((AStruct*)disposableList.Data);
}

Will this work as intended? Is there a way to do this without exposing an implementation detail to the calling method?

Answer 1

I'll admit I don't know much about NativeArray, but in cases like this you can often get the functionality you need by creating a subclass of the class you're working with.

In this case, I'd suggest you create a subclass of NativeList that includes a callback for disposal. Pass it a function that will do the work that you were previously asking the caller to do.

Example subclass:

class MyNativeList<T> : NativeList<T>
{
    protected readonly Action _callAfterDisposal;

    public MyNativeList(Action callAfterDisposal) : base()
    {
        _callAfterDisposal= callAfterDisposal;
    }

    public override Dispose()
    {
        base.Dispose();
        _callAfterDisposal();
    }
}

Setting up the callback:

private unsafe NativeList<AStruct> GetAStructs()
{
    var floatList = new NativeList<float>();
    floatList.Add(0.0f);

    //here we construct the MyNativeList and pass it an action to execute when it is disposed
    var list = new MyNativeList<AStruct>( () => {
        callNativeFunction((AStruct*)floatList.Data);
        floatList.Dispose();
    });

    AStruct a1 = new AStruct();
    a1.floats = (float*)floatList.Data;
    list.Add(a1);

    // ...

    return list;
}

When you do this, the native list of floats is captured in a closed variable. Your caller just needs to dispose of the list per normal, and when the callback is made, the native list of floats gets disposed as well.

using ( var disposableList = GetAStructs() ) 
{
    //Do stuff
}

Notice that GetAStructs() still returns a reference to a NativeList<T> (not a MyNativeList<> ) so the implementation details do not leak to the caller unless they go out of their way to cast the result.