Utiliser des instructions et try-catch () - enfin la répétition?

L'aide de(...) déclaration est sucre syntaxique pour try{} finally {}.

Mais si j'ai ensuite à l'aide d'instruction comme ci-dessous:

using (FileStream fs = File.Open(path))
{


}

Maintenant, je veux attraper les exceptions que l'ouverture de ce fichier pourrait causer (et c'est assez haut risque code qu'elle peut échouer en raison de l'environnement), mais si j'écris try-catch à l'intérieur ne serait-ce pas la répétition? Lorsque le code est compilé à l'IL, je suppose que la répétition sera effacé lorsque le code est JITted?

Cependant, je tiens à intercepter les exceptions de l'ouverture d'un fichier peut provoquer (je devrais donc envelopper le try-catch à l'extérieur de l'instruction à l'aide du champ d'application), et également les exceptions pour ce que je fais à l'intérieur de la à l'aide de bloc de sorte que je dois ajouter le try-catch à l'intérieur du bloc.

Il semble que je suis en ajoutant beaucoup de répétition à ce que le CLR probablement à l'intérieur. Le CLR ajouter des clauses catch?

Mon collègue a fait valoir qu'à l'aide d'instruction est en désordre (mais c'est parce qu'une seule ligne a été un peu long en raison de m'codage en dur des que j'en ai besoin de les changer très rapidement et n'ont pas accès à d'autres parties de la base de code). Dit collègue ne pas utiliser l'instruction à l'aide, mais est-il jamais aucune différence fonctionnelle entre l'instruction d'utilisation et essayez-enfin/try-catch-finally? J'ai vu un cas de ce où les services WCF ont un pas bien connu des cas de coin sur l'utilisation de enfin et le retour des valeurs de (quelque chose finalement). La solution a été d'utiliser une case à bloc. Est-il quelque chose comme cela en C#?

Sur une autre note, sont tous les types qui mettent en œuvre IDisposale propriétaires de ressources non managées? Une discussion avec mon ami de relever la réponse à pas. (J'ai aussi lu quelques discussions dans la section de ce forum, une très bonne connaissance).

source d'informationauteur dotnetdev

c#try-catch-finally using

7

Vous pouvez mettre en œuvre le patron de vous-même si vous devez gérer des exceptions si vous le voulez vraiment. Personnellement, je trouve encore plus simple (et le plus important, le plus clair) à juste wrap de l'aide dans le bloc try/catch.

Mais si vous le faites vous-même, assurez-vous que vous obteniez la bonne. Le Using bloc crée également un anonyme portée bloc de sorte que votre variable devient admissible à la collection plus tôt. Le .Dispose() méthode qui est appelée à la fin de la Using bloquer seulement nettoie non géré ressources, et donc de la mémoire de votre objet contient peut traîner un peu plus longtemps. C'est probablement pas une préoccupation majeure, mais il est utile de rappeler, au cas où.

Donc, pour faire un direct à l'adaptation du modèle, votre code doit ressembler à ceci:
```
{
    FileStream fs;
    try
    {
        fs = File.Open(path);

    }
    catch (FileNotFoundException e) { /* ... */ }
    catch (IOException e) { /* ... */ }
    catch (Exception e) {/* ... */}
    finally
    {
        if (fs != null) fs.Dispose();
    }
}
```
Personnellement, j'aimerais voir Using développée pour prendre en charge Catch et Finally blocs. Depuis qu'ils sont déjà en train d'accomplir une transformation sur le code, il ne semble pas que ce serait ajouter que beaucoup de complexité supplémentaire.
7

Ma préférence serait de garder le à l'aide de la déclaration et de l'envelopper dans un try/catch. L'extérieur try/catch catch quelles que soient les exceptions vous avez besoin de regarder pour, tout en ignorant l'Dispose(). Cela a l'avantage de vous protéger contre vous-même si vous refactoriser cette tard pour déplacer le try/catch ailleurs (comme dans un appel de fonction).

En ce qui concerne votre question sur IDisposable: n'importe qui peut mettre en œuvre ce pour quelque raison que qu'ils aiment. Il n'y a aucune raison pour qu'il soit limité à des ressources non managées. (Si oui ou non il devrait être limité à des ressources non managées dans votre code est une autre question).
4

La plus grande différence entre l'utilisation et essayez-enfin, c'est que l'aide ne appel à la Dispose() méthode. Si vous implémentez votre propre bloc finally peut faire autre logique, par exemple la journalisation, qui ne seraient pas inclus dans l'aide.
4

Si vous avez besoin de traiter explicitement les différents cas exceptionnels, ce qui peut se produire au cours de l'instruction, vous pouvez remplacer using avec try/catch/finally et appel Dispose() explicitement dans le enfin. Ou vous pourriez mettre un try/catch autour de la using bloc de séparer des circonstances exceptionnelles, d'assurer l'élimination.

La seulement chose using n'est de s'assurer Dispose() est appelée, même si une exception est levée dans le bloc. C'est un très limitées, très spécifiques de mise en œuvre de la générale try/[catch]/finally structure.

L'important, c'est qu'aucune de ces options ont un impact réel tant qu'il fait ce dont vous avez besoin, c'est lisible et compréhensible, qui s'en soucie? Ce n'est pas comme un extra essai va être un goulot d'étranglement ou quoi que ce soit!

Pour répondre à votre dernière question - non, IDisposable certainement ne signifie pas que l'opérateur possède des poignées pour les ressources non managées. C'est beaucoup plus simple et plus générique motif que cela. Voici un exemple utile:
```
public class Timer : IDisposable
{
    internal Stopwatch _stopwatch;
    public Timer()
    {
        this._stopwatch = new Stopwatch();
        this._stopwatch.Start();
    }

    public void Dispose()
    {
        this._stopwatch.Stop();
    }
}
```
Nous pouvons l'utiliser pour le temps des choses sans avoir à s'appuient explicitement sur démarrer et arrêter d'être appelé en utilisant:
```
using(Timer timer = new Timer())
{
    //do stuff
}
```
3

La using construire est un raccourci pour un try/finally bloc. Qui est, le compilateur génère:
```
FileStream fs = null;
try
{
    fs = File.Open(path);
    //...
}
finally
{
    if (fs != null)
        fs.Dispose();
}
```
De sorte qu'il est propre à l'utilisation de using si vous n'avez pas besoin d'un catchmais si vous le faites alors vous devriez utiliser une normale try/catch/finally.

Vous devez vous connecter pour publier un commentaire.