Ist es ein guter Ansatz, return inside mit der Anweisung {} aufzurufen?

Ich möchte nur wissen, ob es sicher / gut ist, returninnerhalb eines usingBlocks anzurufen .

Zum Beispiel.

using(var scope = new TransactionScope())
{
  // my core logic
  return true; // if condition met else
  return false;
  scope.Complete();
}

Wir wissen, dass die zuletzt geschweifte Klammer abgesagt dispose()wird. Aber was wird im obigen Fall sein, da returndie Kontrolle aus dem vorgegebenen Bereich (AFAIK) springt ...

1. Wird ich scope.Complete()angerufen?
2. Und so für die dispose()Methode des Oszilloskops.

Es ist absolut sicher, returninnerhalb Ihres usingBlocks aufzurufen , da ein using-Block nur ein try/finallyBlock ist.

In Ihrem obigen Beispiel wird nach der Rückgabe trueder Bereich entsorgt und der Wert zurückgegeben. return falseund scope.Complete()wird nicht angerufen. Disposewird jedoch trotzdem aufgerufen, da es sich im finally-Block befindet.

Ihr Code ist im Wesentlichen derselbe wie dieser (wenn dies das Verständnis erleichtert):

var scope = new TransactionScope())
try
{
  // my core logic
  return true; // if condition met else
  return false;
  scope.Complete();
}
finally
{
  if( scope != null) 
    ((IDisposable)scope).Dispose();
}

Bitte beachten Sie, dass Ihre Transaktion niemals festgeschrieben wird , da es keine Möglichkeit gibt scope.Complete(), die Transaktion festzuschreiben.

Das ist in Ordnung - finallyKlauseln (das ist, was die schließende geschweifte Klammer derusing Klausel unter der Haube tut) werden immer ausgeführt, wenn der Bereich verlassen wird, egal wie.

Dies gilt jedoch nur für Anweisungen, die sich im finally-Block befinden (die bei Verwendung nicht explizit festgelegt werden können using). Daher würde in Ihrem Beispiel scope.Complete()niemals aufgerufen werden (ich erwarte jedoch, dass der Compiler Sie vor nicht erreichbarem Code warnt).

Im Allgemeinen ist es ein guter Ansatz. Aber in Ihrem Fall, wenn Sie zurückkehren, bevor Sie das anrufenscope.Complete() , wird das TransactionScope nur in den Papierkorb verschoben. Kommt auf dein Design an.

In diesem Beispiel wird Complete () nicht aufgerufen, und der Bereich wird entsorgt, vorausgesetzt, er erbt die IDisposable-Schnittstelle.

scope.Complete sollte unbedingt vorher aufgerufen werden return. Der Compiler zeigt eine Warnung an und dieser Code wird niemals aufgerufen.

In Bezug auf sich returnselbst - ja, es ist sicher, es in usingAnweisung zu nennen . Die Verwendung wird übersetzt, um zu versuchen, endlich hinter den Kulissen zu blockieren, und schließlich ist Block sicher auszuführen.

In dem von Ihnen angegebenen Beispiel liegt ein Problem vor. scope.Complete()wird nie genannt. Zweitens ist es keine gute Praxis, returnAnweisungen in usingAnweisungen zu verwenden. Beachten Sie Folgendes:

using(var scope = new TransactionScope())
{
    //have some logic here
    return scope;      
}

In diesem einfachen Beispiel geht es darum, dass; der Wert vonscope ist null, wenn die Verwendung der Anweisung beendet ist.

Es ist also besser, nicht mit Anweisungen nach innen zurückzukehren.

Um sicherzustellen, dass das scope.Complete()aufgerufen wird, wickeln Sie es mit ein try/finally. Das disposewird aufgerufen, weil Sie es mit dem usingalternativen try/finallyBlock umbrochen haben .

using(var scope = new TransactionScope())
{
  try
  {
  // my core logic
  return true; // if condition met else
  return false;
  }
  finally
  {
   scope.Complete();
  }
}

In diesem Beispiel wird scope.Complete () niemals ausgeführt. Der Befehl return bereinigt jedoch alles, was auf dem Stapel zugewiesen ist. Der GC kümmert sich um alles, was nicht referenziert ist. Es gibt also kein Problem, es sei denn, es gibt ein Objekt, das vom GC nicht aufgenommen werden kann.