Modifica di una raccolta .NET integrata int.MaxValue volte e altro - errore di overflow potenziale

Question

Indietro nel tempo in cui .NET Reflector era gratuito L'ho usato per entrare nel codice del framework .NET. E 'venuto alla mia attenzione che la maggior parte delle collezioni in .NET 2.0 (credo che questo è applicabile per le versioni attuali anche) utilizzare il seguente meccanismo per riconoscere le modifiche di raccolta durante i cicli:

public class SomeCollection<T> 
{ 
    internal int version = 0; 

    // code skipped for brevity 

    public void Add(T item) 
    { 
     version++; 

     // add item logic ... 
    } 

    public IEnumerator<T> GetEnumerator() 
    { 
     return new SomeCollectionEnumerator<T>(this); 
    } 
} 

public class SomeCollectionEnumerator<T> : IEnumerator<T> 
{ 
    private SomeCollection<T> collection; 
    private int version; 

    public SomeCollectionEnumerator(SomeCollection<T> collection) 
    { 
     this.version = collection.version; 
     this.collection = collection; 
    } 

    public bool MoveNext() 
    { 
     if (this.version != this.collection.version) 
     { 
      // collection was modified while iterated over 
      throw SomeException(...); 
     } 
     // iteration logic here... 
    } 
} 

Ora immaginate il caso ipotetico di una lunga corsa applicazione (un servizio Web molto utilizzato che deve avere tempi di inattività minimi e deve essere stabile e affidabile) che mantiene in memoria una determinata istanza di raccolta (uno dei tipi di raccolta incorporati in .NET Framework) per tutto il tempo in cui viene eseguita. La raccolta viene modificata abbastanza frequentemente in modo che siano possibili le modifiche int.MaxValue. Esiste il rischio che la linea version++ in ogni metodo di modifica della raccolta generi un'eccezione di overflow (presupponendo che i controlli di overflow non siano disabilitati globalmente).

Devo ammettere che ho dei ricordi deboli dei dettagli del codice riflesso, ma non ricordo l'utilizzo dei blocchi unckecked attorno alle operazioni version++. Questo significa che i tipi di raccolta incorporati in .NET non sono adatti allo scopo di uno scenario applicativo di lunga durata? Solo per curiosità, qualcuno ha incontrato uno scenario di vita reale in cui questo potrebbe effettivamente accadere?

Answer 1

No, perché il compilatore C# fa aritmetica intera unchecked by default. (Questo include la BCL compilato.)