/// <summary> /// Calls <see cref="DisposeExtensions.TryDispose(IDisposable)"/> for each value provided in <paramref name="disposables"/>. /// </summary> /// <remarks> /// <para>If <paramref name="disposables"/> is null the method returns without doing anything.</para> /// </remarks> /// <param name="options">One or more values from <see cref="DisposeOptions"/> controlling how disposal is performed.</param> /// <param name="disposables">An array of objects to attempt disposable of.</param> /// <seealso cref="DisposeAll(object[])"/> /// <seealso cref="DisposeExtensions.TryDispose(IDisposable, DisposeOptions)"/> public static void DisposeAll(DisposeOptions options, params object[] disposables) { if (disposables == null) { return; } List <Exception> exceptions = null; foreach (var item in disposables) { try { DisposeExtensions.TryDispose(item, options); } catch (Exception ex) when(!(ex is OutOfMemoryException)) { if ((options & DisposeOptions.SuppressExceptions) != DisposeOptions.SuppressExceptions) { exceptions = exceptions ?? new List <Exception>(); exceptions.Add(ex); } } } if (exceptions != null) { throw new AggregateException(exceptions); } }
/// <summary> /// Disposes the <paramref name="disposable"/> if it not null using the options specified. /// </summary> /// <param name="disposable">The item to dispose.</param> /// <param name="options">One or more values from <see cref="DisposeOptions"/> that specify details about how to perform the dispose.</param> public static void TryDispose(this IDisposable disposable, DisposeOptions options) { try { disposable?.Dispose(); } catch (OutOfMemoryException) { throw; } catch { if ((options & DisposeOptions.SuppressExceptions) != DisposeOptions.SuppressExceptions) { throw; } } }
/// <summary> /// Disposes all items in an <see cref="IEnumerable{T}"/> that implement <see cref="IDisposable"/> Additionally, if the <paramref name="value"/> also implements <see cref="IDisposable"/> it too will be disposed. /// </summary> /// <remarks> /// <para>Null values will be ignored.</para> /// </remarks> /// <typeparam name="T">The type of value contained in the <see cref="IEnumerable{T}"/>. T must implement <see cref="IDisposable"/>.</typeparam> /// <param name="value">An <see cref="IEnumerable{T}"/> containing the items to be disposed.</param> /// <param name="options">One or more values from the <see cref="DisposeOptions"/> enum that specify rules for the disposal.</param> public static void TryDispose <T>(this IEnumerable <T> value, DisposeOptions options) where T : IDisposable { if (value == null) { return; } foreach (var item in value.Reverse()) { item.TryDispose(options); } //If the enumerable itself is also disposable, //dispose it too. var disposableEnumerable = value as IDisposable; disposableEnumerable?.Dispose(); }
/// <summary> /// Attempts to cast <paramref name="value"/> to <see cref="IDisposable"/> and if success disposes it using <see cref="TryDispose(IDisposable, DisposeOptions)"/>. /// </summary> /// <param name="value">The value to check & dispose if it supports <see cref="IDisposable"/>.</param> /// <param name="options">One or more values from <see cref="DisposeOptions"/> that specify details about how to perform the dispose.</param> public static void TryDispose(this object value, DisposeOptions options) { TryDispose(value as IDisposable, options); }