Disposable

A base class that implements the IDisposable pattern correctly

Disposable Object ensures proper cleanup of both managed and unmanaged resources. It provides a structured way to handle resource disposal and helps prevent memory leaks in your Unity applications.

do NOT use on MonoBehaviour.

Package Info

display name	AceLand Disposable
package name	com.aceland.disposable
latest version	1.0.0
namespace	AceLand.Disposable
git repository	https://github.com/parsue/com.aceland.disposable.git
dependencies

---

Features

• Automatic disposal state tracking

• Separate handling for managed and unmanaged resources

• Protection against multiple disposals

• Proper implementation of IDisposable pattern

• GC optimization through SuppressFinalize

---

Usage Example

public class MyResourceHandler : DisposableObject
{
    private FileStream _fileStream;  // Managed resource
    private IntPtr _nativeHandle;    // Unmanaged resource

    protected override void DisposeManagedResources()
    {
        // Dispose managed resources
        _fileStream?.Dispose();
    }

    protected override void DisposeUnmanagedResources()
    {
        // Clean up unmanaged resources
        if (_nativeHandle != IntPtr.Zero)
        {
            Marshal.FreeHGlobal(_nativeHandle);
            _nativeHandle = IntPtr.Zero;
        }
    }
}

// Using the class
using (var handler = new MyResourceHandler())
{
    // Work with resources
}  // Automatically disposes when leaving scope

Override DisposeManagedResources

Override this method to clean up managed resources:

protected override void DisposeManagedResources()
{
    // Dispose managed objects that implement IDisposable
    _disposableField?.Dispose();
    _listField?.Clear();
}

Override DisposeUnmanagedResources

Override this method to clean up unmanaged resources:

protected override void DisposeUnmanagedResources()
{
    // Clean up unmanaged resources like:
    // - Native memory allocations
    // - File handles
    // - System handles
}

---

Best Practices

• Always use using statements when possible

• Check Disposed property before operations:

public void DoSomething()
{
    if (Disposed) throw new ObjectDisposedException(nameof(MyResourceHandler));
    // Method implementation
}

• Don't call base methods when overriding:

protected override void DisposeManagedResources()
{
    // Don't call base.DisposeManagedResources()
    // Just implement your cleanup
}

• Handle disposal in a deterministic manner:

public void CleanupResources()
{
    if (!Disposed)
    {
        Dispose();
    }
}

---

Important Considerations

• Override DisposeManagedResources for IDisposable objects

• Override DisposeUnmanagedResources for native resources

• Don't throw exceptions from Dispose methods

• Always check Disposed state in public methods

• Use try-finally blocks for critical cleanup operations

---