Rappresenta un insieme di coppie chiave/valore organizzate in base al codice hash della chiave.
System.Collections.Hashtable
System.Configuration.SettingsAttributeDictionary
System.Configuration.SettingsContext
System.Data.PropertyCollection
System.Printing.IndexedProperties.PrintPropertyDictionary
Spazio dei nomi: System.Collections
Assembly: mscorlib (in mscorlib.dll)
<SerializableAttribute> _ <ComVisibleAttribute(True)> _ Public Class Hashtable _ Implements IDictionary, ICollection, IEnumerable, ISerializable, _ IDeserializationCallback, ICloneable
[SerializableAttribute] [ComVisibleAttribute(true)] public class Hashtable : IDictionary, ICollection, IEnumerable, ISerializable, IDeserializationCallback, ICloneable
[SerializableAttribute] [ComVisibleAttribute(true)] public ref class Hashtable : IDictionary, ICollection, IEnumerable, ISerializable, IDeserializationCallback, ICloneable
[<SerializableAttribute>] [<ComVisibleAttribute(true)>] type Hashtable = class interface IDictionary interface ICollection interface IEnumerable interface ISerializable interface IDeserializationCallback interface ICloneable end
Il tipo Hashtable espone i seguenti membri.
| Nome | Descrizione | |
|---|---|---|
|
Hashtable() | Inizializza una nuova istanza vuota della classe Hashtable utilizzando la capacità iniziale, il fattore di carico, il provider di codice hash e l'operatore di confronto predefiniti. |
|
Hashtable(IDictionary) | Inizializza una nuova istanza della classe Hashtable copiando gli elementi dal dizionario specificato nel nuovo oggetto Hashtable. Il nuovo oggetto Hashtable ha una capacità iniziale uguale al numero di elementi copiati e utilizza il fattore di carico, il provider di codice hash e l'operatore di confronto predefiniti. |
|
Hashtable(IEqualityComparer) | Inizializza una nuova istanza vuota della classe Hashtable utilizzando la capacità iniziale e il fattore di carico predefiniti e l'oggetto IEqualityComparer specificato. |
|
Hashtable(Int32) | Inizializza una nuova istanza vuota della classe Hashtable utilizzando la capacità iniziale specificata e il fattore di carico, il provider di codice hash e l'operatore di confronto predefiniti. |
|
Hashtable(IDictionary, IEqualityComparer) | Inizializza una nuova istanza della classe Hashtable copiando gli elementi dal dizionario specificato in un nuovo oggetto Hashtable. Il nuovo oggetto Hashtable ha una capacità iniziale uguale al numero di elementi copiati e utilizza il fattore di carico predefinito e l'oggetto IEqualityComparer specificato. |
|
Hashtable(IDictionary, Single) | Inizializza una nuova istanza della classe Hashtable copiando gli elementi dal dizionario specificato nel nuovo oggetto Hashtable. Il nuovo oggetto Hashtable ha una capacità iniziale uguale al numero di elementi copiati e utilizza il fattore di carico specificato e il provider di codice hash e l'operatore di confronto predefiniti. |
|
Hashtable(IHashCodeProvider, IComparer) | Obsoleta. Inizializza una nuova istanza vuota della classe Hashtable utilizzando la capacità iniziale e il fattore di carico predefiniti e il provider di codice hash e l'operatore di confronto specificati. |
|
Hashtable(Int32, IEqualityComparer) | Inizializza una nuova istanza vuota della classe Hashtable utilizzando la capacità iniziale e l'interfaccia IEqualityComparer specificate e il fattore di carico predefinito. |
|
Hashtable(Int32, Single) | Inizializza una nuova istanza vuota della classe Hashtable utilizzando la capacità iniziale e il fattore di carico specificati e il provider di codice hash e l'operatore di confronto predefiniti. |
|
Hashtable(SerializationInfo, StreamingContext) | Inizializza una nuova istanza vuota della classe Hashtable che è serializzabile mediante l'utilizzo degli oggetti SerializationInfo e StreamingContext specificati. |
|
Hashtable(IDictionary, IHashCodeProvider, IComparer) | Obsoleta. Inizializza una nuova istanza della classe Hashtable copiando gli elementi dal dizionario specificato nel nuovo oggetto Hashtable. Il nuovo oggetto Hashtable ha una capacità iniziale uguale al numero di elementi copiati e utilizza il fattore di carico predefinito e il provider di codice hash e l'operatore di confronto specificati. Questo API è obsoleto. Per un'alternativa, vedere Hashtable(IDictionary, IEqualityComparer). |
|
Hashtable(IDictionary, Single, IEqualityComparer) | Inizializza una nuova istanza della classe Hashtable copiando gli elementi dal dizionario specificato nel nuovo oggetto Hashtable. Il nuovo oggetto Hashtable ha una capacità iniziale uguale al numero di elementi copiati e utilizza il fattore di carico e l'oggetto IEqualityComparer specificati. |
|
Hashtable(Int32, IHashCodeProvider, IComparer) | Obsoleta. Inizializza una nuova istanza vuota della classe Hashtable utilizzando la capacità iniziale, il provider di codice hash e l'operatore di confronto specificati e il fattore di carico predefinito. |
|
Hashtable(Int32, Single, IEqualityComparer) | Inizializza una nuova istanza vuota della classe Hashtable utilizzando la capacità iniziale, il fattore di carico e l'oggetto IEqualityComparer specificati. |
|
Hashtable(IDictionary, Single, IHashCodeProvider, IComparer) | Obsoleta. Inizializza una nuova istanza della classe Hashtable copiando gli elementi dal dizionario specificato nel nuovo oggetto Hashtable. Il nuovo oggetto Hashtable ha una capacità iniziale uguale al numero di elementi copiati e utilizza il fattore di carico, il provider di codice hash e l'operatore di confronto specificati. |
|
Hashtable(Int32, Single, IHashCodeProvider, IComparer) | Obsoleta. Inizializza una nuova istanza vuota della classe Hashtable utilizzando la capacità iniziale, il fattore di carico, il provider di codice hash e l'operatore di confronto specificati. |
| Nome | Descrizione | |
|---|---|---|
|
comparer | Obsoleta. Ottiene o imposta l'oggetto IComparer da utilizzare per la classe Hashtable. |
|
Count | Ottiene il numero di coppie chiave/valore contenute nella classe Hashtable. |
|
EqualityComparer | Ottiene l'interfaccia IEqualityComparer da utilizzare per la classe Hashtable. |
|
hcp | Obsoleta. Ottiene o imposta l'oggetto dal quale verranno distribuiti i codici hash. |
|
IsFixedSize | Ottiene un valore che indica se le dimensioni di Hashtable sono fisse. |
|
IsReadOnly | Ottiene un valore che indica se Hashtable è in sola lettura. |
|
IsSynchronized | Ottiene un valore che indica se l'accesso a Hashtable è sincronizzato (thread-safe). |
|
Item | Ottiene o imposta il valore associato alla chiave specificata. |
|
Keys | Ottiene un'interfaccia ICollection contenente le chiavi presenti nella classe Hashtable. |
|
SyncRoot | Ottiene un oggetto che può essere utilizzato per sincronizzare l'accesso a Hashtable. |
|
Values | Ottiene un oggetto ICollection contenente i valori dell'oggetto Hashtable. |
| Nome | Descrizione | |
|---|---|---|
|
Add | Consente di aggiungere al metodo Hashtable un elemento con la chiave e il valore specificati. |
|
Clear | Consente di rimuovere tutti gli elementi dalla classe Hashtable. |
|
Clone | Consente di creare una copia dei riferimenti di Hashtable. |
|
Contains | Determina se Hashtable contiene una chiave specifica. |
|
ContainsKey | Determina se la classe Hashtable contiene una chiave specifica. |
|
ContainsValue | Determina se la classe Hashtable contiene un valore specifico. |
|
CopyTo | Consente di copiare gli elementi della classe Hashtable in un'istanza della classe Array unidimensionale in corrispondenza dell'indice specificato. |
|
Equals(Object) | Determina se l'oggetto Object specificato è uguale all'oggetto Object corrente. (Ereditato da Object) |
|
Finalize | Consente a un oggetto di provare a liberare risorse ed eseguire altre operazioni di pulitura prima che l'oggetto stesso venga recuperato dalla procedura di Garbage Collection. (Ereditato da Object) |
|
GetEnumerator | Restituisce un'interfaccia IDictionaryEnumerator che consente di scorrere la classe Hashtable. |
|
GetHash | Viene restituito il codice hash per la chiave specificata. |
|
GetHashCode | Funge da funzione hash per un determinato tipo. (Ereditato da Object) |
|
GetObjectData | Consente di implementare l'interfaccia ISerializable restituendo i dati necessari a serializzare la Hashtable. |
|
GetType | Ottiene l'oggetto Type dell'istanza corrente. (Ereditato da Object) |
|
KeyEquals | Consente di confrontare un Object specifico con una chiave specifica nella Hashtable. |
|
MemberwiseClone | Consente di creare una copia dei riferimenti dell'oggetto Object corrente. (Ereditato da Object) |
|
OnDeserialization | Implementa l'interfaccia ISerializable e genera l'evento di deserializzazione quando la deserializzazione è completa. |
|
Remove | Rimuove l'elemento con la chiave specificata dall'oggetto Hashtable. |
|
Synchronized | Restituisce un wrapper sincronizzato (thread-safe) per Hashtable. |
|
ToString | Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object) |
| Nome | Descrizione | |
|---|---|---|
|
AsParallel | Consente la parallelizzazione di una query. (Definito da ParallelEnumerable). |
|
AsQueryable | Converte un oggetto IEnumerable in un oggetto IQueryable. (Definito da Queryable). |
|
Cast<TResult> | Converte gli elementi di un oggetto IEnumerable nel tipo specificato. (Definito da Enumerable). |
|
OfType<TResult> | Filtra gli elementi di un oggetto IEnumerable in base a un tipo specificato. (Definito da Enumerable). |
| Nome | Descrizione | |
|---|---|---|
|
IEnumerable.GetEnumerator | Viene restituito un enumeratore che scorre un insieme. |
Ogni elemento è costituito da una coppia chiave/valore memorizzata in un oggetto DictionaryEntry. Una chiave, a differenza di un valore, non può essere null.
Gli oggetti utilizzati come chiavi da una classe Hashtable sono necessari per eseguire l'override del metodo Object.GetHashCode (o dell'interfaccia IHashCodeProvider) e del metodo Object.Equals (o dell'interfaccia IComparer). Nell'implementazione dei metodi e delle interfacce la distinzione tra maiuscole e minuscole deve essere gestita allo stesso modo; in caso contrario, il comportamento della classe Hashtable potrebbe risultare scorretto. Ad esempio, durante la creazione di una classe Hashtable, è necessario utilizzare la classe CaseInsensitiveHashCodeProvider (o una qualsiasi implementazione IHashCodeProvider in cui non viene fatta distinzione tra maiuscole e minuscole) con la classe CaseInsensitiveComparer (o una qualsiasi implementazione IComparer con distinzione tra maiuscole e minuscole).
Inoltre, è necessario che tali metodi producano gli stessi risultati se chiamati con gli stessi parametri mentre la chiave esiste nella Hashtable. In alternativa è possibile utilizzare un costruttore Hashtable con un parametro IEqualityComparer. Se l'uguaglianza delle chiavi è semplicemente un'uguaglianza di riferimenti, l'implementazione ereditata di Object.GetHashCode e Object.Equals dovrebbe essere sufficiente.
Gli oggetti chiave non devono essere modificati finché utilizzati come chiavi nella Hashtable.
Quando viene aggiunto un elemento alla Hashtable, viene posizionato in una certa sezione, o bucket, in base al codice hash della chiave. Nelle successive ricerche della chiave verrà utilizzato il codice hash della chiave per effettuare la ricerca solo in un determinato bucket, con una sostanziale riduzione del numero di confronti di chiavi necessari per trovare un elemento.
Il fattore di caricamento di una Hashtable determina il rapporto massimo di elementi rispetto ai bucket. Fattori di carico più piccoli determinano tempi di ricerca medi più veloci ma anche un maggior utilizzo di memoria. Il fattore di carico predefinito è 1.0, che in genere rappresenta l'equilibrio migliore tra velocità e dimensioni. È inoltre possibile specificare un diverso fattore di carico quando viene creata la Hashtable.
Quando gli elementi vengono aggiunti a una Hashtable, il fattore di carico effettivo della Hashtable aumenta. Quando il fattore di carico effettivo raggiunge il fattore di carico specificato, il numero di bucket nella classe Hashtable viene automaticamente aumentato. Il nuovo valore sarà pari al numero primo più piccolo che risulti maggiore del doppio del numero corrente di bucket della classe Hashtable.
È necessario che ogni oggetto chiave nella Hashtable fornisca la propria funzione hash, accessibile chiamando GetHash. Tuttavia, qualsiasi oggetto che implementi IHashCodeProvider può essere passato a un costruttore Hashtable; tale funzione hash viene utilizzata per tutti gli oggetti della tabella.
La capacità di una classe Hashtable è il numero di elementi che tale classe Hashtable può contenere. Con l'aggiunta di elementi a Hashtable, la capacità viene automaticamente aumentata secondo le necessità, tramite riallocazione.
L'istruzione foreach del linguaggio C# ( For Each in Visual Basic) richiede il tipo di ogni elemento dell'insieme. Poiché ogni elemento della classe Hashtable è una coppia chiave/valore, il tipo di elemento non è il tipo della chiave né il tipo del valore. Il tipo dell'elemento è invece DictionaryEntry. Di seguito è riportato un esempio.
For Each de As DictionaryEntry In myHashtable ' ... Next de
foreach(DictionaryEntry de in myHashtable) { // ... }
for each(DictionaryEntry de in myHashtable) { // ... }
L'istruzione foreach è un wrapper per l'enumeratore che consente solo di leggere dall'insieme, ma non di scrivere in esso.
Dal momento che la serializzazione e la deserializzazione di un enumeratore per una classe Hashtable possono comportare un riordinamento degli elementi, non è possibile continuare l'enumerazione senza chiamare il metodo Reset.
Nota
|
|---|
|
Poiché le chiavi possono essere ereditate ed è possibile modificarne il comportamento, non è possibile garantirne l'univocità assoluta mediante confronti eseguiti utilizzando il metodo Equals. |
Nell'esempio riportato di seguito viene illustrato come creare, inizializzare ed eseguire varie funzioni su un oggetto Hashtable e come stampare i relativi valori e chiavi.
Imports System Imports System.Collections Module Example Sub Main() ' Create a new hash table. ' Dim openWith As New Hashtable() ' Add some elements to the hash table. There are no ' duplicate keys, but some of the values are duplicates. openWith.Add("txt", "notepad.exe") openWith.Add("bmp", "paint.exe") openWith.Add("dib", "paint.exe") openWith.Add("rtf", "wordpad.exe") ' The Add method throws an exception if the new key is ' already in the hash table. Try openWith.Add("txt", "winword.exe") Catch Console.WriteLine("An element with Key = ""txt"" already exists.") End Try ' The Item property is the default property, so you ' can omit its name when accessing elements. Console.WriteLine("For key = ""rtf"", value = {0}.", _ openWith("rtf")) ' The default Item property can be used to change the value ' associated with a key. openWith("rtf") = "winword.exe" Console.WriteLine("For key = ""rtf"", value = {0}.", _ openWith("rtf")) ' If a key does not exist, setting the default Item property ' for that key adds a new key/value pair. openWith("doc") = "winword.exe" ' ContainsKey can be used to test keys before inserting ' them. If Not openWith.ContainsKey("ht") Then openWith.Add("ht", "hypertrm.exe") Console.WriteLine("Value added for key = ""ht"": {0}", _ openWith("ht")) End If ' When you use foreach to enumerate hash table elements, ' the elements are retrieved as KeyValuePair objects. Console.WriteLine() For Each de As DictionaryEntry In openWith Console.WriteLine("Key = {0}, Value = {1}", _ de.Key, de.Value) Next de ' To get the values alone, use the Values property. Dim valueColl As ICollection = openWith.Values ' The elements of the ValueCollection are strongly typed ' with the type that was specified for hash table values. Console.WriteLine() For Each s As String In valueColl Console.WriteLine("Value = {0}", s) Next s ' To get the keys alone, use the Keys property. Dim keyColl As ICollection = openWith.Keys ' The elements of the KeyCollection are strongly typed ' with the type that was specified for hash table keys. Console.WriteLine() For Each s As String In keyColl Console.WriteLine("Key = {0}", s) Next s ' Use the Remove method to remove a key/value pair. Console.WriteLine(vbLf + "Remove(""doc"")") openWith.Remove("doc") If Not openWith.ContainsKey("doc") Then Console.WriteLine("Key ""doc"" is not found.") End If End Sub End Module ' This code example produces the following output: ' 'An element with Key = "txt" already exists. 'For key = "rtf", value = wordpad.exe. 'For key = "rtf", value = winword.exe. 'Value added for key = "ht": hypertrm.exe ' 'Key = dib, Value = paint.exe 'Key = txt, Value = notepad.exe 'Key = ht, Value = hypertrm.exe 'Key = bmp, Value = paint.exe 'Key = rtf, Value = winword.exe 'Key = doc, Value = winword.exe ' 'Value = paint.exe 'Value = notepad.exe 'Value = hypertrm.exe 'Value = paint.exe 'Value = winword.exe 'Value = winword.exe ' 'Key = dib 'Key = txt 'Key = ht 'Key = bmp 'Key = rtf 'Key = doc ' 'Remove("doc") 'Key "doc" is not found.
using System; using System.Collections; class Example { public static void Main() { // Create a new hash table. // Hashtable openWith = new Hashtable(); // Add some elements to the hash table. There are no // duplicate keys, but some of the values are duplicates. openWith.Add("txt", "notepad.exe"); openWith.Add("bmp", "paint.exe"); openWith.Add("dib", "paint.exe"); openWith.Add("rtf", "wordpad.exe"); // The Add method throws an exception if the new key is // already in the hash table. try { openWith.Add("txt", "winword.exe"); } catch { Console.WriteLine("An element with Key = \"txt\" already exists."); } // The Item property is the default property, so you // can omit its name when accessing elements. Console.WriteLine("For key = \"rtf\", value = {0}.", openWith["rtf"]); // The default Item property can be used to change the value // associated with a key. openWith["rtf"] = "winword.exe"; Console.WriteLine("For key = \"rtf\", value = {0}.", openWith["rtf"]); // If a key does not exist, setting the default Item property // for that key adds a new key/value pair. openWith["doc"] = "winword.exe"; // ContainsKey can be used to test keys before inserting // them. if (!openWith.ContainsKey("ht")) { openWith.Add("ht", "hypertrm.exe"); Console.WriteLine("Value added for key = \"ht\": {0}", openWith["ht"]); } // When you use foreach to enumerate hash table elements, // the elements are retrieved as KeyValuePair objects. Console.WriteLine(); foreach( DictionaryEntry de in openWith ) { Console.WriteLine("Key = {0}, Value = {1}", de.Key, de.Value); } // To get the values alone, use the Values property. ICollection valueColl = openWith.Values; // The elements of the ValueCollection are strongly typed // with the type that was specified for hash table values. Console.WriteLine(); foreach( string s in valueColl ) { Console.WriteLine("Value = {0}", s); } // To get the keys alone, use the Keys property. ICollection keyColl = openWith.Keys; // The elements of the KeyCollection are strongly typed // with the type that was specified for hash table keys. Console.WriteLine(); foreach( string s in keyColl ) { Console.WriteLine("Key = {0}", s); } // Use the Remove method to remove a key/value pair. Console.WriteLine("\nRemove(\"doc\")"); openWith.Remove("doc"); if (!openWith.ContainsKey("doc")) { Console.WriteLine("Key \"doc\" is not found."); } } } /* This code example produces the following output: An element with Key = "txt" already exists. For key = "rtf", value = wordpad.exe. For key = "rtf", value = winword.exe. Value added for key = "ht": hypertrm.exe Key = dib, Value = paint.exe Key = txt, Value = notepad.exe Key = ht, Value = hypertrm.exe Key = bmp, Value = paint.exe Key = rtf, Value = winword.exe Key = doc, Value = winword.exe Value = paint.exe Value = notepad.exe Value = hypertrm.exe Value = paint.exe Value = winword.exe Value = winword.exe Key = dib Key = txt Key = ht Key = bmp Key = rtf Key = doc Remove("doc") Key "doc" is not found. */
using namespace System; using namespace System::Collections; public ref class Example { public: static void Main() { // Create a new hash table. // Hashtable^ openWith = gcnew Hashtable(); // Add some elements to the hash table. There are no // duplicate keys, but some of the values are duplicates. openWith->Add("txt", "notepad.exe"); openWith->Add("bmp", "paint.exe"); openWith->Add("dib", "paint.exe"); openWith->Add("rtf", "wordpad.exe"); // The Add method throws an exception if the new key is // already in the hash table. try { openWith->Add("txt", "winword.exe"); } catch(...) { Console::WriteLine("An element with Key = \"txt\" already exists."); } // The Item property is the default property, so you // can omit its name when accessing elements. Console::WriteLine("For key = \"rtf\", value = {0}.", openWith["rtf"]); // The default Item property can be used to change the value // associated with a key. openWith["rtf"] = "winword.exe"; Console::WriteLine("For key = \"rtf\", value = {0}.", openWith["rtf"]); // If a key does not exist, setting the default Item property // for that key adds a new key/value pair. openWith["doc"] = "winword.exe"; // ContainsKey can be used to test keys before inserting // them. if (!openWith->ContainsKey("ht")) { openWith->Add("ht", "hypertrm.exe"); Console::WriteLine("Value added for key = \"ht\": {0}", openWith["ht"]); } // When you use foreach to enumerate hash table elements, // the elements are retrieved as KeyValuePair objects. Console::WriteLine(); for each( DictionaryEntry de in openWith ) { Console::WriteLine("Key = {0}, Value = {1}", de.Key, de.Value); } // To get the values alone, use the Values property. ICollection^ valueColl = openWith->Values; // The elements of the ValueCollection are strongly typed // with the type that was specified for hash table values. Console::WriteLine(); for each( String^ s in valueColl ) { Console::WriteLine("Value = {0}", s); } // To get the keys alone, use the Keys property. ICollection^ keyColl = openWith->Keys; // The elements of the KeyCollection are strongly typed // with the type that was specified for hash table keys. Console::WriteLine(); for each( String^ s in keyColl ) { Console::WriteLine("Key = {0}", s); } // Use the Remove method to remove a key/value pair. Console::WriteLine("\nRemove(\"doc\")"); openWith->Remove("doc"); if (!openWith->ContainsKey("doc")) { Console::WriteLine("Key \"doc\" is not found."); } } }; int main() { Example::Main(); } /* This code example produces the following output: An element with Key = "txt" already exists. For key = "rtf", value = wordpad.exe. For key = "rtf", value = winword.exe. Value added for key = "ht": hypertrm.exe Key = dib, Value = paint.exe Key = txt, Value = notepad.exe Key = ht, Value = hypertrm.exe Key = bmp, Value = paint.exe Key = rtf, Value = winword.exe Key = doc, Value = winword.exe Value = paint.exe Value = notepad.exe Value = hypertrm.exe Value = paint.exe Value = winword.exe Value = winword.exe Key = dib Key = txt Key = ht Key = bmp Key = rtf Key = doc Remove("doc") Key "doc" is not found. */
.NET Framework
Supportato in: 4, 3.5, 3.0, 2.0, 1.1, 1.0.NET Framework Client Profile
Supportato in: 4, 3.5 SP1Windows 7, Windows Vista SP1 o versione successiva, Windows XP SP3, Windows XP SP2 x64 Edition, Windows Server 2008 (componenti di base del server non supportati), Windows Server 2008 R2 (componenti di base del server supportati con SP1 o versione successiva), Windows Server 2003 SP2
.NET Framework non supporta tutte le versioni di ciascuna piattaforma. Per un elenco delle versioni supportate, vedere Requisiti di sistema di .NET Framework.
Hashtable è thread-safe per quanto riguarda l'utilizzo da parte di più thread di lettura e di un singolo thread di scrittura. È thread-safe per l'utilizzo multi-thread quando solo uno dei thread esegue operazioni di scrittura (aggiornamento) che consentono letture senza blocchi purché i writer vengano serializzati nella classe Hashtable. Per supportare più writer, le operazioni sull'oggetto Hashtable devono venire eseguite tramite il wrapper restituito dal metodo Synchronized, purché non ci siano thread che leggono l'oggetto Hashtable.
L'enumerazione di un insieme non è di per sé una procedura thread-safe. Anche se un insieme è sincronizzato, è possibile che venga modificato da altri thread, con conseguente generazione di un'eccezione da parte dell'enumeratore. Per garantire la thread safety durante l'enumerazione, è possibile bloccare l'insieme per l'intera enumerazione oppure intercettare le eccezioni determinate dalle modifiche apportate da altri thread.
Nota