_>>>File.Delete(tmpFilePath);
_FR>>

_>Выделенное — внутренне противоречивое высказывание

class X : IDisposable
{
  public IDisposable A { get; set; }
  public IDisposable B { get; set; }

  public void Dispose() {
    A.[Super]SafeDispose();
    B.[Super]SafeDispose();
  }
}

static class E
{
  public static void SafeDispose(this IDisposable value) {
    if(value != null) {
      value.Dispose();
    }//if
  }

  public static void SuperSafeDispose(this IDisposable value) {
    if(value != null) {
      try {
        value.Dispose();
      } catch(Exception ex) {
        Debug.Fail("Они бросили исключение. Сволочи!");
      }//try
    }//if
  }
}

_>>>>File.Delete(tmpFilePath);
_FR>>>

_>>Выделенное — внутренне противоречивое высказывание

using (var disposable1 = new Disposable())
using (var disposable2 = new Disposable())
{
    ...
}

[SecuritySafeCritical]
protected override void Dispose(bool disposing)
{
    try
    {
        if (((this._handle != null) && !this._handle.IsClosed) && (this._writePos > 0))
        {
            this.FlushWrite(!disposing);//<--
        }
    }
    finally
    {
        if ((this._handle != null) && !this._handle.IsClosed)
        {
            this._handle.Dispose();
        }
        this._canRead = false;
        this._canWrite = false;
        this._canSeek = false;
        base.Dispose(disposing);
    }
}

_FR>class X : IDisposable
_FR>{
_FR>  public IDisposable A { get; set; }
_FR>  public IDisposable B { get; set; }

_FR>  public void Dispose() {
_FR>    A.[Super]SafeDispose();
_FR>    B.[Super]SafeDispose();
_FR>  }
_FR>}

_FR>static class E
_FR>{
_FR>  public static void SafeDispose(this IDisposable value) {
_FR>    if(value != null) {
_FR>      value.Dispose();
_FR>    }//if
_FR>  }

_FR>  public static void SuperSafeDispose(this IDisposable value) {
_FR>    if(value != null) {
_FR>      try {
_FR>        value.Dispose();
_FR>      } catch(Exception ex) {
_FR>        Debug.Fail("Они бросили исключение. Сволочи!");
_FR>      }//try
_FR>    }//if
_FR>  }
_FR>}
_FR>

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;

namespace ConsoleApplication12
{
    class Program
    {
        static void Main()
        {
            var fileStreams = new[]  {File.OpenRead("1.txt"), File.OpenRead("2.txt")};
            fileStreams.EnsureDispose();
        }
    }

    public static class E
    {
        public static IEnumerable<T> NotNull<T> (this IEnumerable<T> seq)
        {
            if (seq == null)
            {
                return null;
            }

            return seq.Where(i => !ReferenceEquals(i, null));
        }

        public static void EnsureExecute (this IEnumerable<Action> actions)
        {
            if (actions == null)
            {
                return;
            }

            var exceptions = new List<Exception>();

            foreach (var action in actions.NotNull())
            {
                try
                {
                    action();
                }
                catch (Exception ex)
                {
                    exceptions.Add(ex);
                }
            }

            if (exceptions.Count > 0)
            {
                throw new MultyException(exceptions.Last().Message, exceptions);
            }
        }

        public static void EnsureDispose (this IEnumerable<IDisposable> disposables)
        {
            if (disposables == null)
            {
                return;
            }

            EnsureExecute(disposables.NotNull().Select(d => (Action)d.Dispose));
        }
    }

    public class MultyException : Exception
    {
        private readonly IEnumerable<Exception> _exceptions;

        public MultyException()
            : base()
        {
            _exceptions = Enumerable.Empty<Exception>();
        }

        public MultyException(string message, IEnumerable<Exception> exceptions)
            : base (message, (exceptions ?? Enumerable.Empty<Exception>()).FirstOrDefault())
        {
            if (exceptions == null)
            {
                throw new ArgumentNullException("exceptions");
            }
            _exceptions = exceptions;
        }

        public IEnumerable<Exception> Exceptions
        {
            get { return _exceptions; }
        }
    }
}

If an object's Dispose method is called more than once, the object must ignore all calls after the first one. The object must not throw an exception if its Dispose method is called multiple times. Instance methods other than Dispose can throw an ObjectDisposedException when resources are already disposed.

If an object's Dispose method is called more than once, the object must ignore all calls after the first one. The object must not throw an exception if its Dispose method is called multiple times. Dispose can throw an exception if an error occurs because a resource has already been freed and Dispose had not been called previously.

_>>>Выделенное — внутренне противоречивое высказывание

_>using (var disposable1 = new Disposable())
_>using (var disposable2 = new Disposable())
_>{
_>    ...
_>}

using (var disposable1 = new Disposable())
using (var disposable2 = new Disposable()) {
  try {
  } catch(SomeException) {
  }//try
}//using

_>[SecuritySafeCritical]
_>protected override void Dispose(bool disposing)
_>{
_>    try
_>    {
_>        if (((this._handle != null) && !this._handle.IsClosed) && (this._writePos > 0))
_>        {
_>            this.FlushWrite(!disposing);//<--
_>        }
_>    }
_>    finally
_>    {
_>        if ((this._handle != null) && !this._handle.IsClosed)
_>        {
_>            this._handle.Dispose();
_>        }
_>        this._canRead = false;
_>        this._canWrite = false;
_>        this._canSeek = false;
_>        base.Dispose(disposing);
_>    }
_>}

_FR>>class X : IDisposable
_FR>>{
_FR>>  public IDisposable A { get; set; }
_FR>>  public IDisposable B { get; set; }

_FR>>  public void Dispose() {
_FR>>    A.[Super]SafeDispose();
_FR>>    B.[Super]SafeDispose();
_FR>>  }
_FR>>}

…