Comment se débarrasser de la CA2000 avertissement lorsque la propriété est transférée?

Le code suivant génère deux CA2000 avertissements (parmi d'autres, mais ce n'est pas le point).

public sealed class Item: IDisposable
{
    public void Dispose() {}
}

public sealed class ItemContainer
{
    public void Add(Item item)
    {
    }
}

public sealed class Test: IDisposable
{
    private ICollection<Item> itemCollection;
    private ItemContainer itemContainer;

    private void Add(Item item)
    {
        itemCollection.Add(item);
    }

    public void Initialize()
    {
        var item1 = new Item(); //no warning
        itemCollection.Add(item1);

        var item2 = new Item(); //CA2000: call Dispose on object item2
        Add(item2);

        var item3 = new Item(); //CA2000: call Dispose on object item3
        itemContainer.Add(item3);
    }

    public void Dispose() {}
}

Noter qu'il n'y a pas d'avertissement générés pour élément1. Il semble, d'Analyse de Code suppose que le ICollection prendra la responsabilité de l'élément et, éventuellement, de la jeter.

Est-il un moyen pour marquer mon Add de méthodes, de sorte que l'avertissement s'en va?

Je suis à la recherche de quelque chose de semblable à ValidatedNotNullAttribute pour CA1062.

Edit: pour préciser: ce n'est pas mon vrai code. Dans le code réel, tout est bien disposé.

C'est juste que CA ne reconnaît pas que l'appel à mon Add méthodes de transferts de propriété.
Je le voudrais pour traiter mon Ajouter des méthodes dans la même façon qu'il traite ICollection.Add.

À l'élimination dans le même champ d'application n'est pas une option.

OriginalL'auteur Henrik | 2010-10-14

c#code-analysis visual-studio-2010

10

Voulez-vous corriger le code ou tout simplement supprimer les avertissements? La suppression de l'avertissement est simple:
```
[SuppressMessage("Microsoft.Reliability",
                 "CA2000:DisposeObjectsBeforeLosingScope",
                 Justification = "Your reasons go here")]
public void Initialize()
{
    //...
}
```
Je préfère le voir avec une justification et stylecop.
Et donc auraient-I. Modifié pour inclure...
Je préfère ne pas supprimer l'avertissement. Si la méthode est modifié plus tard, j'aimerais recevoir un avertissement, le cas échéant.
La CA2000 analyse les règles semblent être assez grossière et trop zélé. Aussi loin que je peux dire que la seule façon de le maintenir heureux, c'est de disposer de votre IDisposables dans le même champ d'application (avec quelques rares exceptions comme le comportement des item1 dans votre exemple).
Beaucoup de code-règles d'analyse sont grossières et trop zélé. Un ou deux sont juste stupides. Je ne pense pas qu'on peut les considérer sur un pied d'égalité avec les avertissements du compilateur, mais comme une classe différente de l'outil.

OriginalL'auteur LukeH
6

J'ai aussi demandé à connect.microsoft.com et c'est ce à quoi ils ont répondu:

Vous pouvez contourner le problème en ayant le conteneur/objet de collection qui ajoute le jetable objet de mettre en œuvre ICollection ou ICollection<T>. La méthode qui effectue le complément doit également avoir un nom commençant par "Ajouter".

Et bien sûr: quand la classe de Test met en œuvre ICollection<Item>, puis l'avertissement disparaît. C'est une solution acceptable pour le cas en question. Mais c'est encore une question ouverte, que faire, quand il n'est pas approprié pour mettre en œuvre ICollection pour indiquer le transfert de propriété.
```
public sealed class Test: IDisposable, ICollection<Item>
{
    public void Initialize()
    {
        var item1 = new Item(); //no warning
        itemCollection.Add(item1);

        var item2 = new Item(); //no warning
        ((ICollection<Item>)this).Add(item2);

        var item3 = new Item(); //no warning
        AddSomething(item3);
    }

    //... implement ICollection and Method AddSomething
}
```
Accepté ma propre réponse, parce que c'est ce que j'ai fait dans ce cas: mettre en œuvre ICollection sur une classe qui est déjà mis en œuvre IDisposable. Je suis totalement d'accord avec Damien: il n'aurait plus de sens, si CA nécessaire à la fois IDisposable et ICollection.
Est-il possible de mettre en place quelque chose de similaire sur un Dictionnaire de produits jetables par des index?

OriginalL'auteur Henrik
6

Je sais que c'est un exemple de code, et donc que cette solution de contournement serait de travailler dans votre code réel, je ne pouvais pas le dire.

Dans ce cas particulier, si vous déplacez l'objet de création de code dans une méthode, qui renvoie l'Élément nouveau, puis il disparaîtra, par exemple, modifier:
```
public void Initialize()
 {
  var item1 = new Item(); //no warning
  itemCollection.Add(item1);

  var item2 = CreateItem(); //CA2000 no longer appears
  Add(item2);

  var item3 = new Item(); //CA2000: call Dispose on object item3
  itemContainer.Add(item3);
 }

 private Item CreateItem()
 {
  return new Item();
 }
```
De toute évidence, la méthode CreateItem pourrait être passé arbitraire de paramètres à passer à l'Élément constructeur.

Modifier

Avoir vu Henrik réponse, et la réponse sur se Connecter, tout ce que je peux dire, c'est bletch. Il n'y a aucune garantie qu'un ICollection mise en œuvre met également en œuvre IDisposable, et tandis que son posté exemple ne mettre en œuvre IDisposable, apparemment ce n'est pas nécessaire de fermer l'analyse de code (j'en serais un peu d'accord si vous aviez à mettre en œuvre à la fois). Une classe de mise en œuvre de ICollection, mais pas la mise en œuvre de IDisposable est très peu probable de faire face à l'élimination des objets contenus correctement.

Mais dans ce cas, l'avertissement n'apparaît pas même si Ajouter(item2) est supprimé et item2 est vérifiable, ne sont pas éliminés. Donc, je pourrais tout aussi bien supprimer l'avertissement.
plus je passe de temps à la recherche à de cette, la plus confus que je reçois. Il n'y a aucune garantie que tout particulier ICollection<T> la mise en œuvre adéquate de disposer d'éléments ajoutés à cela, donc je continue à me demander pourquoi nous sommes le pas se CA2000 pour élément1.
Décerné par la générosité de cette réponse. Cela pourrait être utile dans le cas où la méthode CreateItem en interne ajouté l'élément à une collection pour s'assurer qu'il est disposé.

OriginalL'auteur Damien_The_Unbeliever
1

Mais bien sûr, la première chose à faire est de faire réellement la méthode dispose nettoyer les membres de la collection. Je suppose que c'est juste une erreur dans l'exemple plutôt que le code réel.

Au-delà de ça, je voudrais juste supprimer l'avertissement. J'ai très fortement soutiennent que toute suppression:
1. Doit être de très courte portée, afin de ne pas éliminer un autre cas de l'avertissement qui est une véritable erreur.
2. Doivent être annotées avec un commentaire, peu importe combien de mort cérébrale évidente, il semble que l'avertissement est sécuritaire de le supprimer.
Cela dit, je pense que l'analyse de la CA2000 est si mauvaise que celle de ne pas être la peine de l'avoir activée par défaut, mais seulement dans les examens occasionnels. Après un certain nombre de faux-positifs, un avertissement peut même pas être considéré comme un avertissement, pas plus, juste le bruit qui se cache réel de mises en garde et donc de rendre le code plus susceptibles d'être buggé.

OriginalL'auteur Jon Hanna

Vous devez vous connecter pour publier un commentaire.