Ich habe also eine Methode, die von einem WCF-Dienst als solche verfügbar gemacht wird:

<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>

Ich habe ein globales DataUnitOfWork-Objekt (das IDisposable implementiert), das von Ninject über ein Konstruktorargument instanziiert wird, wenn ein Dienstaufruf eingeht. Beim Debuggen, wenn ich es verwende

<code>using(_unitOfWork)
</code>

Das _unitOfWork-Objekt wird sofort nach dem Verlassen des Gültigkeitsbereichs entsorgt und dann von Ninject erneut aufgerufen (obwohl es als entsorgt markiert wurde, passiert nichts.) Ohne die using-Anweisung behandelt Ninject das Entsorgen.

Lange Rede kurzer Sinn, gibt es dafür eine allgemeine Faustregel? Ich hatte Angst vor dem ganzen IDisposable, nachdem alles, was ich lese, darauf hindeutet, es niemals zu benutzen oder in bestimmten eklektischen Situationen zu benutzen, aber es verwirrt mich immer.

Jede Eingabe wird geschätzt.

Oh, auch wenn ich hier sowieso schreibe, warum wird dann genau GC.SuppressFinalize () beim Entsorgen aufgerufen? Wie unterscheiden sich Entsorgen und Finalisieren?