Y a-t-il des effets secondaires du retour de l'intérieur d'une instruction using ()?

De retour d' une valeur de la méthode de l' intérieur d' une instruction à l' aide qui obtient un DataContext semble toujours un travail bien , comme ceci:

public static Transaction GetMostRecentTransaction(int singleId)
{
    using (var db = new DataClasses1DataContext())
    {
        var transaction = (from t in db.Transactions
                              orderby t.WhenCreated descending
                              where t.Id == singleId
                              select t).SingleOrDefault();
        return transaction;
    }
}

Mais je me sens toujours que je devrais fermais quelque chose avant de sortir des supports à l' aide, par exemple par transaction définissant avant l'instruction à l' aide, obtenir la valeur de ce à l' intérieur des crochets, puis de revenir après les parenthèses.

La définition et le renvoi de la variable en dehors des crochets d'utilisation seraient-ils une meilleure pratique ou conserveraient-ils les ressources de quelque manière que ce soit?

Non, je pense que c'est plus clair de cette façon. Ne vous inquiétez pas, Disposesera toujours appelé "à la sortie" - et seulement après que la valeur de retour est entièrement évaluée. Si une exception est levée à tout moment (y compris l'évaluation de la valeur de retour) Disposesera toujours appelée aussi.

Alors que vous avez certainement pu prendre la route plus longue, il est deux lignes supplémentaires qui ajoutent juste cochonneries et le contexte supplémentaire pour garder une trace de (mentalement). En fait, vous n'avez pas vraiment besoin de la variable locale supplémentaire - bien qu'elle puisse être pratique en termes de débogage. Vous pourriez juste avoir:

public static Transaction GetMostRecentTransaction(int singleId)
{
    using (var db = new DataClasses1DataContext())
    {
        return (from t in db.Transactions
                orderby t.WhenCreated descending
                where t.Id == singleId
                select t).SingleOrDefault();
    }
}

En effet, je pourrais même être tenté d'utiliser la notation par points, et de mettre la Wherecondition dans le SingleOrDefault:

public static Transaction GetMostRecentTransaction(int singleId)
{
    using (var db = new DataClasses1DataContext())
    {
        return db.Transactions.OrderByDescending(t => t.WhenCreated)
                              .SingleOrDefault(t => t.Id == singleId);
    }
}

Jetez un œil à ceci

Comprendre l'instruction 'using' en C #

Le CLR convertit votre code en MSIL. Et l'instruction using est traduite en un bloc try and finally. C'est ainsi que l'instruction using est représentée dans IL. Une déclaration d'utilisation est traduite en trois parties: acquisition, utilisation et élimination. La ressource est d'abord acquise, puis l'utilisation est incluse dans une instruction try avec une clause finally. L'objet est ensuite supprimé dans la clause finally.

Il n'y a pas d' effets secondaires du retour de l'intérieur d'une using()déclaration.

La question de savoir si cela rend le code le plus lisible est une autre discussion.

Je pense que c'est pareil. Il n'y a rien de mal dans le code. Le framework .NET ne se soucierait pas de l'emplacement de création de l'objet. Ce qui compte, c'est de savoir s'il est référencé ou non.

Oui, il peut y avoir un effet secondaire. Par exemple, si vous utilisez la même technique dans la méthode Action ASP.NET MVC, vous obtiendrez l'erreur suivante: «L'instance ObjectContext a été supprimée et ne peut plus être utilisée pour les opérations qui nécessitent une connexion»

public ActionResult GetMostRecentTransaction(int singleId)
{
    using (var db = new DataClasses1DataContext())
    {
        var transaction = (from t in db.Transactions
                              orderby t.WhenCreated descending
                              where t.Id == singleId
                              select t).SingleOrDefault();
        return PartialView("_transactionPartial", transaction);
    }
}