Então, eu tenho um método exposto de um serviço WCF como tal:

<code>public GetAllCommentsResponse GetAllComments(GetAllCommentsRequest request)
{
    var response = new GetAllCommentsResponse();

    using(_unitOfWork)
        try
        {
            Guard.ArgNotNull(request, "request");

            var results = _unitOfWork.CommentRepository.Get(d => d.Id > 0).ToArray();

            //... Do rest of stuff here
        }
        catch (Exception ex)
        {
            response.Success = false;
            response.FailureInformation = ex.Message;
            Logger.LogError("GetAllComments Method Failed", ex);
        }

    return response;
}
</code>

Eu tenho um objeto DataUnitOfWork global (que implementa IDisposable) que é instanciado por Ninject através de um argumento de construtor quando uma chamada de serviço vem dentro. Ao depurar, se eu usar

<code>using(_unitOfWork)
</code>

o objeto _unitOfWork é descartado imediatamente depois de sair do escopo, em seguida, é chamado novamente por Ninject (embora tenha sido marcado como descartado, portanto, nada acontece). Sem a instrução using, o Ninject manipula o descarte.

Longa história curta, existe uma regra geral para isso? Eu tenho medo de toda a coisa descartável depois que tudo que eu leio parece indicar nunca usá-la, ou usá-la em certas situações ecléticas, mas isso sempre me confunde.

Qualquer entrada é apreciada.

Ah, também enquanto estou aqui digitando mesmo assim, por que exatamente há uma chamada para GC.SuppressFinalize () ao descartar? Como Dispose e Finalize diferem?