Existe-t-il un moyen d'avoir une instruction using avec des cibles créées dynamiquement?

Question

Disons que j'ai défini une classe MyDisposable : IDisposable. Je sais que je peux fournir une liste codée en dur de IDisposable objets à la déclaration using:

using (MyDisposable firstDisposable = new MyDisposable(), 
    secondDisposable = new MyDisposable()) 
{ 
    // do something 
} 

Maintenant, nous allons dire que j'ai quelques méthodes qui effectuent des opérations sur une collection de mes objets jetables, et je veux faire à l'intérieur d'une instruction using. Il pourrait ressembler à ceci (mais cela ne fonctionne pas bien sûr parce que le bloc à l'aide attend un ou plusieurs objets IDisposable et je passe un seul objet de collection):

using (var myDisposables = GetMyDisposables()) 
{ 
    foreach (var myDisposable in myDisposables) 
    { 
     DoSomething(myDisposable); 
     DoSomethingElse(myDisposable); 
    } 
} 

Voici les autres méthodes, juste pour la clarté :

static List<MyDisposable> GetMyDisposables() 
{ 
    throw new NotImplementedException(); // return a list of MyDisposable objects 
} 

static void DoSomething(MyDisposable withMyDisposable) 
{ 
    // something 
} 

static void DoSomethingElse(MyDisposable withMyDisposable) 
{ 
    // something else 
} 

Est-il possible que je peux y arriver avec la déclaration using? Ou dois-je simplement jeter la déclaration et la jeter manuellement?

Answer 1

Une approche que vous pouvez prendre est de faire une collection de IDisposable objets, ce qui est également IDisposable:

class CollectionOfDisposable<T> : IDisposable where T : IDisposable { 
    public IList<T> Members {get; private set;} 
    public CollectionOfDisposable(IEnumerable<T> members) { 
     Members = members.ToList(); 
    } 
    public void Dispose() { 
     var exceptions = new List<Exception>(); 
     foreach (var item in Members) { 
      try { 
       item.Dispose(); 
      } catch (Exception e) { 
       exceptions.Add(e); 
      } 
     } 
     if (exceptions.Count != 0) { 
      throw new AggregateException(exceptions); 
     } 
    } 
} 

Maintenant, vous pouvez écrire ceci:

using (var myDisposables = GetMyDisposables()) { 
    foreach (var myDisposable in myDisposables.Members) { 
     DoSomething(myDisposable); 
     DoSomethingElse(myDisposable); 
    } 
} 

static CollectionOfDisposable<MyDisposable> GetMyDisposables() { 
    throw new NotImplementedException(); // return a list of MyDisposable objects 
} 

Answer 2

Vous devrez créer votre propre type qui implémente IDisposable et accepte une collection d'objets jetables dans son constructeur, les retenant et les jetant tous quand ils sont jetés.