/// <summary> /// Ensure that the given native object <paramref name="wrapper"/> /// has not been disposed. /// </summary> /// <param name="wrapper">The native object wrapper to validate.</param> public unsafe static void NotDisposed(NativeDisposable wrapper) { if (wrapper.IsDisposed) { throw new ObjectDisposedException(wrapper.GetType().Name); } }
/// <summary> /// Safely executes the given native function call for a given /// object, ensuring that the object is not disposed and that it /// will be kept alive until the end of the call. /// </summary> /// <param name="call">The function to invoke.</param> /// <param name="obj">The object to validate and keep alive.</param> public static T NativeCall <T>(Func <T> call, NativeDisposable obj) { Ensure.NotDisposed(obj); T ret = call(); GC.KeepAlive(obj); return(ret); }
/// <summary> /// Creates a lazy value that will be created by the given /// <paramref name="valueFactory"/> upon first use, ensuring /// that the given <paramref name="nativeObject"/> is not disposed. /// Subsequent values will be returned without invoking the factory. /// </summary> /// <param name="valueFactory">The function to invoke to populate the value.</param> /// <param name="nativeObject">A native object to ensure is not disposed.</param> public LazyNative(Func <T> valueFactory, NativeDisposable nativeObject) { Ensure.ArgumentNotNull(valueFactory, "valueFactory"); Ensure.ArgumentNotNull(nativeObject, "nativeObject"); this.valueFactory = valueFactory; this.nativeObject = nativeObject; }
/// <summary> /// Invoke the given function and ensure that its return code /// indicates success; ie that it is non-negative. /// </summary> /// <param name="call">The function call to invoke.</param> /// <param name="obj">The object to validate and keep alive.</param> public static void NativeSuccess(Func <int> call, NativeDisposable obj) { NativeSuccess(NativeCall <int>(call, obj)); }