Originariamente inviato da Stoicenko
in lettura il problema non si pone, in scrittura si, è buona abitudine usare oggetti lock o semafori (mutex) per gestire le risorse condivise (e usare la parola chiava "volatile" in tali variabili)
Si ok, non lo avevo spacificato ma pensavo appunto a strumenti di questo tipo

se intendi dire che nel corpo del thread (dowork) qualsiasi thread accede alle variabili (locali) create da qualsiasi altro thread allora no.. chiarisci questo punto.
intendo dire che se io ho N thread e questi utilizzano la stessa area di memoria (parto da questo punto fermo, se sbaglio ditemelo per favore) chiunque di questi istanzi degli oggetti (intendo istanze di classi definite a livello di progetto) potrà vedere questi ultimi raggiunti da altri thread, se questi ne conoscono la locazione. Non è così? questa è più una perplessità teorica che una esigenza pratica di questo lavoro.

corretto.. per averlo asincrono esistono altri metodi..
Ok, quindi scatenare un evento è di fatto come chiamare una funzione, con la differenza che si passa via delegate. Quindi ciascun chiamante (parlo di thread) avrà la sua copia in stack e andrà in parallelo MA se tale metodo va a scrivere membri dell'istanza (che è unica e non n-uplicata) a cui appartiene allora questo meccanismo in parallelo andrà ovviamente gestito con lock etc.

esistono apposta i blocchi "lock" e i semafori (mutex) per fare ciò
Ok

tecnicamente non cambia molto, la gestione ad eventi ti semplifica solamente le cose (in questo caso) e ti permette di sapere sempre chi è il thread che ha eseguito la funzione
Ok, quindi ricapitolando...se ho N thread e voglio accentrare la logica di gestione degli errori in una classe (mi pare il procedimento più pulito) posso fare le seguenti cose: (uso gli stessi nomi di esempio usati nel mio primo intervento)
1) mi creo un oggetto OBJ2 dedicato alla gestione errori con un metodo base, ad es errorManagement(), tale metodo deve tener conto della possibilità di girare in N copie in parallelo per cui tramite lock etc sto attento a non scrivere contemporaneamente su risorse condivise. Definisco un delegate a cui errorMangement sia compatibile. Definisco in ogni OBJ1 un evento sendErr(). A livello di main associo ad ogni evento degli OBJ1 l'handler errorMangement(). Lancio i vari thread associati al metodo DoWork() di ogni OBJ1 e il gioco è fatto.
2) Ad ogni OBJ1 passo l'oggetto (il puntatore) OBJ2 e poi a quel punto ogni thread secondario potrà lanciare direttamente il metodo errorManagement() accedendo al membro di OBJ1 che conserva il puntatore all'oggetto OBJ2 (anche qui si tratta di una chiamata ad un metodo per cui ogni thread avrà il proprio stack e la propria copia di funzione da eseguire)
3) Definisco un delegate a livello di trhead principale, lo associo al metodo errorManagement() di OBJ2 e poi passo il delegate (quindi il suo puntatore) a tutti gli OBJ1 (che se lo salvano). Ogni thread secondario in esecuzione potrà quindi chiamare il delegate puntando così in automatico alla funzione errorMangement() di cui verrà caricata la copia nello stack locale e quindi eseguita con i soliti accorgimenti per le risorse condivise.
4) Soluzione incerta: definisco a livello di main un evento sendError che poi passo ad ogni OBJ1 così da definirne uno unico per tutti...si può? O definendo l'evento a livello di main non è accessibile poi dai vari OBJ1? Non vedo problemi legati al fatto che siamo in thread diversi ma piuttosto forse problemi legati all'accessibilità di un evento da oggetti diversi...

Ok, per ora è tutto...grazie per tutte le considerazioni che vorrete fare