Est-ce une bonne approche d'appeler return à l'intérieur en utilisant l'instruction {}?

Je veux juste savoir est-ce une approche sûre / bonne pour appeler à l' returnintérieur d'un usingbloc.

Par ex.

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

Nous savons que la dernière accolade la plus bouclée dispose()sera annulée . Mais que sera-t-il dans le cas ci-dessus, puisque returnsaute le contrôle hors de la portée donnée (AFAIK) ...

1. Mon scope.Complete()être appelé?
2. Et il en va de même pour la dispose()méthode du scope .

Il est parfaitement sûr d'appeler à l' returnintérieur de votre usingbloc, car un bloc using n'est qu'un try/finallybloc.

Dans votre exemple ci-dessus après le retour true, la portée sera supprimée et la valeur retournée. return false, et nescope.Complete() sera pas appelé. Disposecependant sera appelé indépendamment car il réside dans le bloc finally.

Votre code est essentiellement le même (si cela facilite la compréhension):

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();
}

Veuillez noter que votre transaction ne sera jamais validée car il n'y a aucun moyen scope.Complete()de valider la transaction.

C'est très bien - les finallyclauses (c'est ce que fait l'accolade fermante de la usingclause sous le capot) sont toujours exécutées lorsque la portée est laissée, peu importe comment.

Cependant, cela n'est vrai que pour les instructions qui se trouvent dans le bloc finally (qui ne peut pas être défini explicitement lors de l'utilisation using). Par conséquent, dans votre exemple, scope.Complete()ne serait jamais appelé (je m'attends à ce que le compilateur vous avertisse du code inaccessible).

En général, c'est une bonne approche. Mais dans votre cas, si vous revenez avant d'appeler le scope.Complete(), il supprimera simplement le TransactionScope. Dépend de votre conception.

Ainsi, dans cet exemple, Complete () n'est pas appelé et la portée est supprimée, en supposant qu'elle hérite de l'interface IDisposable.

scope.Complete doit être appelé avant return. Le compilateur affichera un avertissement et ce code ne sera jamais appelé.

En ce qui concerne returnlui-même - oui, il est prudent de l'appeler usingdéclaration intérieure . L'utilisation est traduite en bloc try-finally dans les coulisses et enfin block doit être certainement exécuté.

Dans l'exemple que vous avez fourni, il y a un problème; scope.Complete()n'est jamais appelé. Deuxièmement, ce n'est pas une bonne pratique d'utiliser des returninstructions dans des usinginstructions. Reportez-vous à ce qui suit:

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

Dans cet exemple simple, le point est que; la valeur de scopesera nulle lorsque l'instruction d'utilisation est terminée.

Il vaut donc mieux ne pas retourner à l'intérieur en utilisant des instructions.

Pour vous assurer que le scope.Complete()sera appelé, enveloppez-le avec try/finally. Le disposeest appelé parce que vous l'avez enveloppé avec le usingqui est un try/finallybloc alternatif .

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

Dans cet exemple, scope.Complete () ne s'exécutera jamais. Cependant, la commande return nettoiera tout ce qui est assigné sur la pile. Le GC s'occupera de tout ce qui n'est pas référencé. Donc, à moins qu'il y ait un objet qui ne puisse pas être capté par le GC, il n'y a pas de problème.